KILLED
proof of input_Wfbczqk5vu.trs
# AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished


The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).

(0) CpxTRS
(1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxTRS
(3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(4) CpxTRS
(5) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(6) CdtProblem
    (7) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxRelTRS
    (9) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) CpxRelTRS
    (11) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (12) typed CpxTrs
    (13) OrderProof [LOWER BOUND(ID), 11 ms]
    (14) typed CpxTrs
    (15) RewriteLemmaProof [LOWER BOUND(ID), 321 ms]
    (16) typed CpxTrs
    (17) RewriteLemmaProof [LOWER BOUND(ID), 101 ms]
    (18) BEST
        (19) proven lower bound
            (20) LowerBoundPropagationProof [FINISHED, 0 ms]
            (21) BOUNDS(n^1, INF)
        (22) typed CpxTrs
(23) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(24) CdtProblem
    (25) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (26) CdtProblem
    (27) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (28) CdtProblem
    (29) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (30) CdtProblem
    (31) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (32) CpxRelTRS
        (33) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
        (34) CpxTRS
        (35) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (36) CpxWeightedTrs
            (37) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
            (38) CpxTypedWeightedTrs
            (39) CompletionProof [UPPER BOUND(ID), 0 ms]
            (40) CpxTypedWeightedCompleteTrs
                (41) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
                (42) CpxTypedWeightedCompleteTrs
                (43) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (44) CpxRNTS
                (45) InliningProof [UPPER BOUND(ID), 120 ms]
                (46) CpxRNTS
                (47) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
                (48) CpxRNTS
                (49) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
                (50) CpxRNTS
                (51) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (52) CpxRNTS
                (53) IntTrsBoundProof [UPPER BOUND(ID), 189 ms]
                (54) CpxRNTS
                (55) IntTrsBoundProof [UPPER BOUND(ID), 22 ms]
                (56) CpxRNTS
                (57) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (58) CpxRNTS
                (59) IntTrsBoundProof [UPPER BOUND(ID), 161 ms]
                (60) CpxRNTS
                (61) IntTrsBoundProof [UPPER BOUND(ID), 115 ms]
                (62) CpxRNTS
                (63) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (64) CpxRNTS
                (65) IntTrsBoundProof [UPPER BOUND(ID), 689 ms]
                (66) CpxRNTS
                (67) IntTrsBoundProof [UPPER BOUND(ID), 218 ms]
                (68) CpxRNTS
                (69) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (70) CpxRNTS
                (71) IntTrsBoundProof [UPPER BOUND(ID), 1325 ms]
                (72) CpxRNTS
                (73) IntTrsBoundProof [UPPER BOUND(ID), 217 ms]
                (74) CpxRNTS
                (75) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (76) CpxRNTS
                (77) IntTrsBoundProof [UPPER BOUND(ID), 463 ms]
                (78) CpxRNTS
                (79) IntTrsBoundProof [UPPER BOUND(ID), 306 ms]
                (80) CpxRNTS
            (81) CompletionProof [UPPER BOUND(ID), 0 ms]
            (82) CpxTypedWeightedCompleteTrs
                (83) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (84) CpxRNTS
    (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
        (87) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (88) CdtProblem
        (89) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (90) CdtProblem
        (91) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (92) CdtProblem
        (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (94) CdtProblem
        (95) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (96) CdtProblem
        (97) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (98) CdtProblem
        (99) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 43 ms]
        (100) CdtProblem
        (101) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (102) CdtProblem
        (103) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (104) CdtProblem
        (105) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 40 ms]
        (106) CdtProblem
        (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (108) CdtProblem
        (109) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (110) CdtProblem
        (111) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 32 ms]
        (112) CdtProblem
        (113) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (114) CdtProblem
        (115) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (116) CdtProblem
        (117) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (118) CdtProblem
        (119) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (120) CdtProblem
        (121) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (122) CdtProblem
        (123) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (124) CdtProblem
        (125) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (126) CdtProblem
        (127) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (128) CdtProblem
        (129) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (130) CdtProblem
        (131) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (132) CdtProblem
        (133) CdtRewritingProof [BOTH BOUNDS(ID, ID), 4 ms]
        (134) CdtProblem
        (135) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (136) CdtProblem
        (137) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (138) CdtProblem
        (139) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (140) CdtProblem
        (141) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (142) CdtProblem
        (143) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (144) CdtProblem
        (145) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (146) CdtProblem
        (147) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (148) CdtProblem
        (149) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (150) CdtProblem
        (151) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (152) CdtProblem
        (153) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (154) CdtProblem
        (155) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (156) CdtProblem
        (157) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 3 ms]
        (158) CdtProblem
        (159) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (160) CdtProblem
        (161) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (162) CdtProblem
        (163) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 1 ms]
        (164) CdtProblem
        (165) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (166) CdtProblem
        (167) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (168) CdtProblem
        (169) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 338 ms]
        (170) CdtProblem
        (171) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 302 ms]
        (172) CdtProblem
        (173) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 319 ms]
        (174) CdtProblem
(175) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(176) CpxWeightedTrs
    (177) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (178) CpxTypedWeightedTrs
    (179) CompletionProof [UPPER BOUND(ID), 0 ms]
    (180) CpxTypedWeightedCompleteTrs
        (181) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (182) CpxTypedWeightedCompleteTrs
        (183) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (184) CpxRNTS
        (185) InliningProof [UPPER BOUND(ID), 48 ms]
        (186) CpxRNTS
        (187) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (188) CpxRNTS
        (189) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
        (190) CpxRNTS
        (191) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (192) CpxRNTS
        (193) IntTrsBoundProof [UPPER BOUND(ID), 159 ms]
        (194) CpxRNTS
        (195) IntTrsBoundProof [UPPER BOUND(ID), 8 ms]
        (196) CpxRNTS
        (197) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (198) CpxRNTS
        (199) IntTrsBoundProof [UPPER BOUND(ID), 484 ms]
        (200) CpxRNTS
        (201) IntTrsBoundProof [UPPER BOUND(ID), 171 ms]
        (202) CpxRNTS
        (203) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (204) CpxRNTS
        (205) IntTrsBoundProof [UPPER BOUND(ID), 1018 ms]
        (206) CpxRNTS
        (207) IntTrsBoundProof [UPPER BOUND(ID), 226 ms]
        (208) CpxRNTS
    (209) CompletionProof [UPPER BOUND(ID), 0 ms]
    (210) CpxTypedWeightedCompleteTrs
        (211) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (212) CpxRNTS


----------------------------------------

(0)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   p(0) -> 0
   p(s(x)) -> x
   minus(x, 0) -> x
   minus(s(x), s(y)) -> minus(x, y)
   minus(x, s(y)) -> p(minus(x, y))
   div(0, s(y)) -> 0
   div(s(x), s(y)) -> s(div(minus(s(x), s(y)), s(y)))
   log(s(0), s(s(y))) -> 0
   log(s(s(x)), s(s(y))) -> s(log(div(minus(x, y), s(s(y))), s(s(y))))

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(1) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(2)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   p(0') -> 0'
   p(s(x)) -> x
   minus(x, 0') -> x
   minus(s(x), s(y)) -> minus(x, y)
   minus(x, s(y)) -> p(minus(x, y))
   div(0', s(y)) -> 0'
   div(s(x), s(y)) -> s(div(minus(s(x), s(y)), s(y)))
   log(s(0'), s(s(y))) -> 0'
   log(s(s(x)), s(s(y))) -> s(log(div(minus(x, y), s(s(y))), s(s(y))))

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(3) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(4)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   p(0) -> 0
   p(s(x)) -> x
   minus(x, 0) -> x
   minus(s(x), s(y)) -> minus(x, y)
   minus(x, s(y)) -> p(minus(x, y))
   div(0, s(y)) -> 0
   div(s(x), s(y)) -> s(div(minus(s(x), s(y)), s(y)))
   log(s(0), s(s(y))) -> 0
   log(s(s(x)), s(s(y))) -> s(log(div(minus(x, y), s(s(y))), s(s(y))))

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(5) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(6)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   p(0) -> 0
   p(s(z0)) -> z0
   minus(z0, 0) -> z0
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
   log(s(0), s(s(z0))) -> 0
   log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))
Tuples:
   P(0) -> c
   P(s(z0)) -> c1
   MINUS(z0, 0) -> c2
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
   DIV(0, s(z0)) -> c5
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(0), s(s(z0))) -> c7
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
S tuples:
   P(0) -> c
   P(s(z0)) -> c1
   MINUS(z0, 0) -> c2
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
   DIV(0, s(z0)) -> c5
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(0), s(s(z0))) -> c7
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
K tuples:none
Defined Rule Symbols:   p_1, minus_2, div_2, log_2

Defined Pair Symbols:   P_1, MINUS_2, DIV_2, LOG_2

Compound Symbols:   c, c1, c2, c3_1, c4_2, c5, c6_2, c7, c8_3


----------------------------------------

(7) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(8)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   P(0) -> c
   P(s(z0)) -> c1
   MINUS(z0, 0) -> c2
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
   DIV(0, s(z0)) -> c5
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(0), s(s(z0))) -> c7
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))

The (relative) TRS S consists of the following rules:

   p(0) -> 0
   p(s(z0)) -> z0
   minus(z0, 0) -> z0
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
   log(s(0), s(s(z0))) -> 0
   log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))

Rewrite Strategy: INNERMOST
----------------------------------------

(9) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(10)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   P(0') -> c
   P(s(z0)) -> c1
   MINUS(z0, 0') -> c2
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
   DIV(0', s(z0)) -> c5
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(0'), s(s(z0))) -> c7
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))

The (relative) TRS S consists of the following rules:

   p(0') -> 0'
   p(s(z0)) -> z0
   minus(z0, 0') -> z0
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   div(0', s(z0)) -> 0'
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
   log(s(0'), s(s(z0))) -> 0'
   log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))

Rewrite Strategy: INNERMOST
----------------------------------------

(11) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Inferred types.
----------------------------------------

(12)
Obligation:
Innermost TRS:
Rules:
P(0') -> c
P(s(z0)) -> c1
MINUS(z0, 0') -> c2
MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
DIV(0', s(z0)) -> c5
DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
LOG(s(0'), s(s(z0))) -> c7
LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
p(0') -> 0'
p(s(z0)) -> z0
minus(z0, 0') -> z0
minus(s(z0), s(z1)) -> minus(z0, z1)
minus(z0, s(z1)) -> p(minus(z0, z1))
div(0', s(z0)) -> 0'
div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
log(s(0'), s(s(z0))) -> 0'
log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))

Types:
P :: 0':s -> c:c1
0' :: 0':s
c :: c:c1
s :: 0':s -> 0':s
c1 :: c:c1
MINUS :: 0':s -> 0':s -> c2:c3:c4
c2 :: c2:c3:c4
c3 :: c2:c3:c4 -> c2:c3:c4
c4 :: c:c1 -> c2:c3:c4 -> c2:c3:c4
minus :: 0':s -> 0':s -> 0':s
DIV :: 0':s -> 0':s -> c5:c6
c5 :: c5:c6
c6 :: c5:c6 -> c2:c3:c4 -> c5:c6
LOG :: 0':s -> 0':s -> c7:c8
c7 :: c7:c8
c8 :: c7:c8 -> c5:c6 -> c2:c3:c4 -> c7:c8
div :: 0':s -> 0':s -> 0':s
p :: 0':s -> 0':s
log :: 0':s -> 0':s -> 0':s
hole_c:c11_9 :: c:c1
hole_0':s2_9 :: 0':s
hole_c2:c3:c43_9 :: c2:c3:c4
hole_c5:c64_9 :: c5:c6
hole_c7:c85_9 :: c7:c8
gen_0':s6_9 :: Nat -> 0':s
gen_c2:c3:c47_9 :: Nat -> c2:c3:c4
gen_c5:c68_9 :: Nat -> c5:c6
gen_c7:c89_9 :: Nat -> c7:c8

----------------------------------------

(13) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
MINUS, minus, DIV, LOG, div, log

They will be analysed ascendingly in the following order:
minus < MINUS
MINUS < DIV
MINUS < LOG
minus < DIV
minus < LOG
minus < div
minus < log
DIV < LOG
div < LOG
div < log

----------------------------------------

(14)
Obligation:
Innermost TRS:
Rules:
P(0') -> c
P(s(z0)) -> c1
MINUS(z0, 0') -> c2
MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
DIV(0', s(z0)) -> c5
DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
LOG(s(0'), s(s(z0))) -> c7
LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
p(0') -> 0'
p(s(z0)) -> z0
minus(z0, 0') -> z0
minus(s(z0), s(z1)) -> minus(z0, z1)
minus(z0, s(z1)) -> p(minus(z0, z1))
div(0', s(z0)) -> 0'
div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
log(s(0'), s(s(z0))) -> 0'
log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))

Types:
P :: 0':s -> c:c1
0' :: 0':s
c :: c:c1
s :: 0':s -> 0':s
c1 :: c:c1
MINUS :: 0':s -> 0':s -> c2:c3:c4
c2 :: c2:c3:c4
c3 :: c2:c3:c4 -> c2:c3:c4
c4 :: c:c1 -> c2:c3:c4 -> c2:c3:c4
minus :: 0':s -> 0':s -> 0':s
DIV :: 0':s -> 0':s -> c5:c6
c5 :: c5:c6
c6 :: c5:c6 -> c2:c3:c4 -> c5:c6
LOG :: 0':s -> 0':s -> c7:c8
c7 :: c7:c8
c8 :: c7:c8 -> c5:c6 -> c2:c3:c4 -> c7:c8
div :: 0':s -> 0':s -> 0':s
p :: 0':s -> 0':s
log :: 0':s -> 0':s -> 0':s
hole_c:c11_9 :: c:c1
hole_0':s2_9 :: 0':s
hole_c2:c3:c43_9 :: c2:c3:c4
hole_c5:c64_9 :: c5:c6
hole_c7:c85_9 :: c7:c8
gen_0':s6_9 :: Nat -> 0':s
gen_c2:c3:c47_9 :: Nat -> c2:c3:c4
gen_c5:c68_9 :: Nat -> c5:c6
gen_c7:c89_9 :: Nat -> c7:c8


Generator Equations:
gen_0':s6_9(0) <=> 0'
gen_0':s6_9(+(x, 1)) <=> s(gen_0':s6_9(x))
gen_c2:c3:c47_9(0) <=> c2
gen_c2:c3:c47_9(+(x, 1)) <=> c3(gen_c2:c3:c47_9(x))
gen_c5:c68_9(0) <=> c5
gen_c5:c68_9(+(x, 1)) <=> c6(gen_c5:c68_9(x), c2)
gen_c7:c89_9(0) <=> c7
gen_c7:c89_9(+(x, 1)) <=> c8(gen_c7:c89_9(x), c5, c2)


The following defined symbols remain to be analysed:
minus, MINUS, DIV, LOG, div, log

They will be analysed ascendingly in the following order:
minus < MINUS
MINUS < DIV
MINUS < LOG
minus < DIV
minus < LOG
minus < div
minus < log
DIV < LOG
div < LOG
div < log

----------------------------------------

(15) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
minus(gen_0':s6_9(n11_9), gen_0':s6_9(n11_9)) -> gen_0':s6_9(0), rt in Omega(0)

Induction Base:
minus(gen_0':s6_9(0), gen_0':s6_9(0)) ->_R^Omega(0)
gen_0':s6_9(0)

Induction Step:
minus(gen_0':s6_9(+(n11_9, 1)), gen_0':s6_9(+(n11_9, 1))) ->_R^Omega(0)
minus(gen_0':s6_9(n11_9), gen_0':s6_9(n11_9)) ->_IH
gen_0':s6_9(0)

We have rt in Omega(1) and sz in O(n). Thus, we have irc_R in Omega(n^0).
----------------------------------------

(16)
Obligation:
Innermost TRS:
Rules:
P(0') -> c
P(s(z0)) -> c1
MINUS(z0, 0') -> c2
MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
DIV(0', s(z0)) -> c5
DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
LOG(s(0'), s(s(z0))) -> c7
LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
p(0') -> 0'
p(s(z0)) -> z0
minus(z0, 0') -> z0
minus(s(z0), s(z1)) -> minus(z0, z1)
minus(z0, s(z1)) -> p(minus(z0, z1))
div(0', s(z0)) -> 0'
div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
log(s(0'), s(s(z0))) -> 0'
log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))

Types:
P :: 0':s -> c:c1
0' :: 0':s
c :: c:c1
s :: 0':s -> 0':s
c1 :: c:c1
MINUS :: 0':s -> 0':s -> c2:c3:c4
c2 :: c2:c3:c4
c3 :: c2:c3:c4 -> c2:c3:c4
c4 :: c:c1 -> c2:c3:c4 -> c2:c3:c4
minus :: 0':s -> 0':s -> 0':s
DIV :: 0':s -> 0':s -> c5:c6
c5 :: c5:c6
c6 :: c5:c6 -> c2:c3:c4 -> c5:c6
LOG :: 0':s -> 0':s -> c7:c8
c7 :: c7:c8
c8 :: c7:c8 -> c5:c6 -> c2:c3:c4 -> c7:c8
div :: 0':s -> 0':s -> 0':s
p :: 0':s -> 0':s
log :: 0':s -> 0':s -> 0':s
hole_c:c11_9 :: c:c1
hole_0':s2_9 :: 0':s
hole_c2:c3:c43_9 :: c2:c3:c4
hole_c5:c64_9 :: c5:c6
hole_c7:c85_9 :: c7:c8
gen_0':s6_9 :: Nat -> 0':s
gen_c2:c3:c47_9 :: Nat -> c2:c3:c4
gen_c5:c68_9 :: Nat -> c5:c6
gen_c7:c89_9 :: Nat -> c7:c8


Lemmas:
minus(gen_0':s6_9(n11_9), gen_0':s6_9(n11_9)) -> gen_0':s6_9(0), rt in Omega(0)


Generator Equations:
gen_0':s6_9(0) <=> 0'
gen_0':s6_9(+(x, 1)) <=> s(gen_0':s6_9(x))
gen_c2:c3:c47_9(0) <=> c2
gen_c2:c3:c47_9(+(x, 1)) <=> c3(gen_c2:c3:c47_9(x))
gen_c5:c68_9(0) <=> c5
gen_c5:c68_9(+(x, 1)) <=> c6(gen_c5:c68_9(x), c2)
gen_c7:c89_9(0) <=> c7
gen_c7:c89_9(+(x, 1)) <=> c8(gen_c7:c89_9(x), c5, c2)


The following defined symbols remain to be analysed:
MINUS, DIV, LOG, div, log

They will be analysed ascendingly in the following order:
MINUS < DIV
MINUS < LOG
DIV < LOG
div < LOG
div < log

----------------------------------------

(17) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
MINUS(gen_0':s6_9(n776_9), gen_0':s6_9(n776_9)) -> gen_c2:c3:c47_9(n776_9), rt in Omega(1 + n776_9)

Induction Base:
MINUS(gen_0':s6_9(0), gen_0':s6_9(0)) ->_R^Omega(1)
c2

Induction Step:
MINUS(gen_0':s6_9(+(n776_9, 1)), gen_0':s6_9(+(n776_9, 1))) ->_R^Omega(1)
c3(MINUS(gen_0':s6_9(n776_9), gen_0':s6_9(n776_9))) ->_IH
c3(gen_c2:c3:c47_9(c777_9))

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(18)
Complex Obligation (BEST)

----------------------------------------

(19)
Obligation:
Proved the lower bound n^1 for the following obligation:

Innermost TRS:
Rules:
P(0') -> c
P(s(z0)) -> c1
MINUS(z0, 0') -> c2
MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
DIV(0', s(z0)) -> c5
DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
LOG(s(0'), s(s(z0))) -> c7
LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
p(0') -> 0'
p(s(z0)) -> z0
minus(z0, 0') -> z0
minus(s(z0), s(z1)) -> minus(z0, z1)
minus(z0, s(z1)) -> p(minus(z0, z1))
div(0', s(z0)) -> 0'
div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
log(s(0'), s(s(z0))) -> 0'
log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))

Types:
P :: 0':s -> c:c1
0' :: 0':s
c :: c:c1
s :: 0':s -> 0':s
c1 :: c:c1
MINUS :: 0':s -> 0':s -> c2:c3:c4
c2 :: c2:c3:c4
c3 :: c2:c3:c4 -> c2:c3:c4
c4 :: c:c1 -> c2:c3:c4 -> c2:c3:c4
minus :: 0':s -> 0':s -> 0':s
DIV :: 0':s -> 0':s -> c5:c6
c5 :: c5:c6
c6 :: c5:c6 -> c2:c3:c4 -> c5:c6
LOG :: 0':s -> 0':s -> c7:c8
c7 :: c7:c8
c8 :: c7:c8 -> c5:c6 -> c2:c3:c4 -> c7:c8
div :: 0':s -> 0':s -> 0':s
p :: 0':s -> 0':s
log :: 0':s -> 0':s -> 0':s
hole_c:c11_9 :: c:c1
hole_0':s2_9 :: 0':s
hole_c2:c3:c43_9 :: c2:c3:c4
hole_c5:c64_9 :: c5:c6
hole_c7:c85_9 :: c7:c8
gen_0':s6_9 :: Nat -> 0':s
gen_c2:c3:c47_9 :: Nat -> c2:c3:c4
gen_c5:c68_9 :: Nat -> c5:c6
gen_c7:c89_9 :: Nat -> c7:c8


Lemmas:
minus(gen_0':s6_9(n11_9), gen_0':s6_9(n11_9)) -> gen_0':s6_9(0), rt in Omega(0)


Generator Equations:
gen_0':s6_9(0) <=> 0'
gen_0':s6_9(+(x, 1)) <=> s(gen_0':s6_9(x))
gen_c2:c3:c47_9(0) <=> c2
gen_c2:c3:c47_9(+(x, 1)) <=> c3(gen_c2:c3:c47_9(x))
gen_c5:c68_9(0) <=> c5
gen_c5:c68_9(+(x, 1)) <=> c6(gen_c5:c68_9(x), c2)
gen_c7:c89_9(0) <=> c7
gen_c7:c89_9(+(x, 1)) <=> c8(gen_c7:c89_9(x), c5, c2)


The following defined symbols remain to be analysed:
MINUS, DIV, LOG, div, log

They will be analysed ascendingly in the following order:
MINUS < DIV
MINUS < LOG
DIV < LOG
div < LOG
div < log

----------------------------------------

(20) LowerBoundPropagationProof (FINISHED)
Propagated lower bound.
----------------------------------------

(21)
BOUNDS(n^1, INF)

----------------------------------------

(22)
Obligation:
Innermost TRS:
Rules:
P(0') -> c
P(s(z0)) -> c1
MINUS(z0, 0') -> c2
MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
DIV(0', s(z0)) -> c5
DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
LOG(s(0'), s(s(z0))) -> c7
LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
p(0') -> 0'
p(s(z0)) -> z0
minus(z0, 0') -> z0
minus(s(z0), s(z1)) -> minus(z0, z1)
minus(z0, s(z1)) -> p(minus(z0, z1))
div(0', s(z0)) -> 0'
div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
log(s(0'), s(s(z0))) -> 0'
log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))

Types:
P :: 0':s -> c:c1
0' :: 0':s
c :: c:c1
s :: 0':s -> 0':s
c1 :: c:c1
MINUS :: 0':s -> 0':s -> c2:c3:c4
c2 :: c2:c3:c4
c3 :: c2:c3:c4 -> c2:c3:c4
c4 :: c:c1 -> c2:c3:c4 -> c2:c3:c4
minus :: 0':s -> 0':s -> 0':s
DIV :: 0':s -> 0':s -> c5:c6
c5 :: c5:c6
c6 :: c5:c6 -> c2:c3:c4 -> c5:c6
LOG :: 0':s -> 0':s -> c7:c8
c7 :: c7:c8
c8 :: c7:c8 -> c5:c6 -> c2:c3:c4 -> c7:c8
div :: 0':s -> 0':s -> 0':s
p :: 0':s -> 0':s
log :: 0':s -> 0':s -> 0':s
hole_c:c11_9 :: c:c1
hole_0':s2_9 :: 0':s
hole_c2:c3:c43_9 :: c2:c3:c4
hole_c5:c64_9 :: c5:c6
hole_c7:c85_9 :: c7:c8
gen_0':s6_9 :: Nat -> 0':s
gen_c2:c3:c47_9 :: Nat -> c2:c3:c4
gen_c5:c68_9 :: Nat -> c5:c6
gen_c7:c89_9 :: Nat -> c7:c8


Lemmas:
minus(gen_0':s6_9(n11_9), gen_0':s6_9(n11_9)) -> gen_0':s6_9(0), rt in Omega(0)
MINUS(gen_0':s6_9(n776_9), gen_0':s6_9(n776_9)) -> gen_c2:c3:c47_9(n776_9), rt in Omega(1 + n776_9)


Generator Equations:
gen_0':s6_9(0) <=> 0'
gen_0':s6_9(+(x, 1)) <=> s(gen_0':s6_9(x))
gen_c2:c3:c47_9(0) <=> c2
gen_c2:c3:c47_9(+(x, 1)) <=> c3(gen_c2:c3:c47_9(x))
gen_c5:c68_9(0) <=> c5
gen_c5:c68_9(+(x, 1)) <=> c6(gen_c5:c68_9(x), c2)
gen_c7:c89_9(0) <=> c7
gen_c7:c89_9(+(x, 1)) <=> c8(gen_c7:c89_9(x), c5, c2)


The following defined symbols remain to be analysed:
DIV, LOG, div, log

They will be analysed ascendingly in the following order:
DIV < LOG
div < LOG
div < log

----------------------------------------

(23) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(24)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   p(0) -> 0
   p(s(z0)) -> z0
   minus(z0, 0) -> z0
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
   log(s(0), s(s(z0))) -> 0
   log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))
Tuples:
   P(0) -> c
   P(s(z0)) -> c1
   MINUS(z0, 0) -> c2
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
   DIV(0, s(z0)) -> c5
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(0), s(s(z0))) -> c7
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
S tuples:
   P(0) -> c
   P(s(z0)) -> c1
   MINUS(z0, 0) -> c2
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
   DIV(0, s(z0)) -> c5
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(0), s(s(z0))) -> c7
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
K tuples:none
Defined Rule Symbols:   p_1, minus_2, div_2, log_2

Defined Pair Symbols:   P_1, MINUS_2, DIV_2, LOG_2

Compound Symbols:   c, c1, c2, c3_1, c4_2, c5, c6_2, c7, c8_3


----------------------------------------

(25) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 5 trailing nodes:
   DIV(0, s(z0)) -> c5
   P(0) -> c
   LOG(s(0), s(s(z0))) -> c7
   MINUS(z0, 0) -> c2
   P(s(z0)) -> c1

----------------------------------------

(26)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   p(0) -> 0
   p(s(z0)) -> z0
   minus(z0, 0) -> z0
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
   log(s(0), s(s(z0))) -> 0
   log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(P(minus(z0, z1)), MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
K tuples:none
Defined Rule Symbols:   p_1, minus_2, div_2, log_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_2, c6_2, c8_3


----------------------------------------

(27) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(28)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   p(0) -> 0
   p(s(z0)) -> z0
   minus(z0, 0) -> z0
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
   log(s(0), s(s(z0))) -> 0
   log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
K tuples:none
Defined Rule Symbols:   p_1, minus_2, div_2, log_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c6_2, c8_3, c4_1


----------------------------------------

(29) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   log(s(0), s(s(z0))) -> 0
   log(s(s(z0)), s(s(z1))) -> s(log(div(minus(z0, z1), s(s(z1))), s(s(z1))))

----------------------------------------

(30)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
K tuples:none
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c6_2, c8_3, c4_1


----------------------------------------

(31) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(32)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))

The (relative) TRS S consists of the following rules:

   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))

Rewrite Strategy: INNERMOST
----------------------------------------

(33) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(34)
Obligation:
The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))

S is empty.
Rewrite Strategy: INNERMOST
----------------------------------------

(35) RelTrsToWeightedTrsProof (BOTH BOUNDS(ID, ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(36)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1)) [1]
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1))) [1]
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1)) [1]
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1)) [1]
   minus(s(z0), s(z1)) -> minus(z0, z1) [0]
   minus(z0, s(z1)) -> p(minus(z0, z1)) [0]
   minus(z0, 0) -> z0 [0]
   p(0) -> 0 [0]
   p(s(z0)) -> z0 [0]
   div(0, s(z0)) -> 0 [0]
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1))) [0]

Rewrite Strategy: INNERMOST
----------------------------------------

(37) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(38)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1)) [1]
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1))) [1]
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1)) [1]
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1)) [1]
   minus(s(z0), s(z1)) -> minus(z0, z1) [0]
   minus(z0, s(z1)) -> p(minus(z0, z1)) [0]
   minus(z0, 0) -> z0 [0]
   p(0) -> 0 [0]
   p(s(z0)) -> z0 [0]
   div(0, s(z0)) -> 0 [0]
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1))) [0]

The TRS has the following type information:
MINUS :: s:0 -> s:0 -> c3:c4
s :: s:0 -> s:0
c3 :: c3:c4 -> c3:c4
DIV :: s:0 -> s:0 -> c6
c6 :: c6 -> c3:c4 -> c6
minus :: s:0 -> s:0 -> s:0
LOG :: s:0 -> s:0 -> c8
c8 :: c8 -> c6 -> c3:c4 -> c8
div :: s:0 -> s:0 -> s:0
c4 :: c3:c4 -> c3:c4
p :: s:0 -> s:0
0 :: s:0

Rewrite Strategy: INNERMOST
----------------------------------------

(39) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:

   MINUS_2
   DIV_2
   LOG_2

(c) The following functions are completely defined:

   minus_2
   p_1
   div_2

Due to the following rules being added:

   minus(v0, v1) -> 0 [0]
   p(v0) -> 0 [0]
   div(v0, v1) -> 0 [0]

And the following fresh constants:    const, const1, const2

----------------------------------------

(40)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1)) [1]
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1))) [1]
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1)) [1]
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1)) [1]
   minus(s(z0), s(z1)) -> minus(z0, z1) [0]
   minus(z0, s(z1)) -> p(minus(z0, z1)) [0]
   minus(z0, 0) -> z0 [0]
   p(0) -> 0 [0]
   p(s(z0)) -> z0 [0]
   div(0, s(z0)) -> 0 [0]
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1))) [0]
   minus(v0, v1) -> 0 [0]
   p(v0) -> 0 [0]
   div(v0, v1) -> 0 [0]

The TRS has the following type information:
MINUS :: s:0 -> s:0 -> c3:c4
s :: s:0 -> s:0
c3 :: c3:c4 -> c3:c4
DIV :: s:0 -> s:0 -> c6
c6 :: c6 -> c3:c4 -> c6
minus :: s:0 -> s:0 -> s:0
LOG :: s:0 -> s:0 -> c8
c8 :: c8 -> c6 -> c3:c4 -> c8
div :: s:0 -> s:0 -> s:0
c4 :: c3:c4 -> c3:c4
p :: s:0 -> s:0
0 :: s:0
const :: c3:c4
const1 :: c6
const2 :: c8

Rewrite Strategy: INNERMOST
----------------------------------------

(41) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(42)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1)) [1]
   DIV(s(z0), s(z1)) -> c6(DIV(minus(z0, z1), s(z1)), MINUS(s(z0), s(z1))) [1]
   DIV(s(z0), s(z1)) -> c6(DIV(p(minus(s(z0), z1)), s(z1)), MINUS(s(z0), s(z1))) [1]
   DIV(s(z0), s(z1)) -> c6(DIV(0, s(z1)), MINUS(s(z0), s(z1))) [1]
   LOG(s(s(s(z0'))), s(s(s(z1')))) -> c8(LOG(div(minus(z0', z1'), s(s(s(z1')))), s(s(s(z1')))), DIV(minus(z0', z1'), s(s(s(z1')))), MINUS(s(z0'), s(z1'))) [1]
   LOG(s(s(s(z0'))), s(s(s(z1')))) -> c8(LOG(div(minus(z0', z1'), s(s(s(z1')))), s(s(s(z1')))), DIV(p(minus(s(z0'), z1')), s(s(s(z1')))), MINUS(s(z0'), s(z1'))) [1]
   LOG(s(s(s(z0'))), s(s(s(z1')))) -> c8(LOG(div(minus(z0', z1'), s(s(s(z1')))), s(s(s(z1')))), DIV(0, s(s(s(z1')))), MINUS(s(z0'), s(z1'))) [1]
   LOG(s(s(s(z0''))), s(s(s(z1'')))) -> c8(LOG(div(p(minus(s(z0''), z1'')), s(s(s(z1'')))), s(s(s(z1'')))), DIV(minus(z0'', z1''), s(s(s(z1'')))), MINUS(s(z0''), s(z1''))) [1]
   LOG(s(s(z0)), s(s(s(z1'')))) -> c8(LOG(div(p(minus(z0, z1'')), s(s(s(z1'')))), s(s(s(z1'')))), DIV(p(minus(z0, z1'')), s(s(s(z1'')))), MINUS(z0, s(z1''))) [1]
   LOG(s(s(z0)), s(s(s(z1'')))) -> c8(LOG(div(p(minus(z0, z1'')), s(s(s(z1'')))), s(s(s(z1'')))), DIV(0, s(s(s(z1'')))), MINUS(z0, s(z1''))) [1]
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(z0, s(s(0))), MINUS(z0, 0)) [1]
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(0, s(s(0))), MINUS(z0, 0)) [1]
   LOG(s(s(s(z01))), s(s(s(z11)))) -> c8(LOG(div(0, s(s(s(z11)))), s(s(s(z11)))), DIV(minus(z01, z11), s(s(s(z11)))), MINUS(s(z01), s(z11))) [1]
   LOG(s(s(z0)), s(s(s(z12)))) -> c8(LOG(div(0, s(s(s(z12)))), s(s(s(z12)))), DIV(p(minus(z0, z12)), s(s(s(z12)))), MINUS(z0, s(z12))) [1]
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(0, s(s(0))), s(s(0))), DIV(z0, s(s(0))), MINUS(z0, 0)) [1]
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(0, s(s(z1))), s(s(z1))), DIV(0, s(s(z1))), MINUS(z0, z1)) [1]
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1)) [1]
   minus(s(z0), s(z1)) -> minus(z0, z1) [0]
   minus(s(z02), s(s(z13))) -> p(minus(z02, z13)) [0]
   minus(z0, s(s(z14))) -> p(p(minus(z0, z14))) [0]
   minus(z0, s(0)) -> p(z0) [0]
   minus(z0, s(z1)) -> p(0) [0]
   minus(z0, 0) -> z0 [0]
   p(0) -> 0 [0]
   p(s(z0)) -> z0 [0]
   div(0, s(z0)) -> 0 [0]
   div(s(z0), s(z1)) -> s(div(minus(z0, z1), s(z1))) [0]
   div(s(z0), s(z1)) -> s(div(p(minus(s(z0), z1)), s(z1))) [0]
   div(s(z0), s(z1)) -> s(div(0, s(z1))) [0]
   minus(v0, v1) -> 0 [0]
   p(v0) -> 0 [0]
   div(v0, v1) -> 0 [0]

The TRS has the following type information:
MINUS :: s:0 -> s:0 -> c3:c4
s :: s:0 -> s:0
c3 :: c3:c4 -> c3:c4
DIV :: s:0 -> s:0 -> c6
c6 :: c6 -> c3:c4 -> c6
minus :: s:0 -> s:0 -> s:0
LOG :: s:0 -> s:0 -> c8
c8 :: c8 -> c6 -> c3:c4 -> c8
div :: s:0 -> s:0 -> s:0
c4 :: c3:c4 -> c3:c4
p :: s:0 -> s:0
0 :: s:0
const :: c3:c4
const1 :: c6
const2 :: c8

Rewrite Strategy: INNERMOST
----------------------------------------

(43) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   const => 0
   const1 => 0
   const2 => 0

----------------------------------------

(44)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + z0, z1)), 1 + z1) + MINUS(1 + z0, 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z0, z1), 1 + z1) + MINUS(1 + z0, 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + z1) + MINUS(1 + z0, 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z0, 1 + (1 + 0)) + MINUS(z0, 0) :|: z' = 1 + (1 + 0), z0 >= 0, z = 1 + (1 + z0)
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z0, 0) :|: z' = 1 + (1 + 0), z0 >= 0, z = 1 + (1 + z0)
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z0, z1'')), 1 + (1 + (1 + z1''))), 1 + (1 + (1 + z1''))) + DIV(p(minus(z0, z1'')), 1 + (1 + (1 + z1''))) + MINUS(z0, 1 + z1'') :|: z' = 1 + (1 + (1 + z1'')), z0 >= 0, z = 1 + (1 + z0), z1'' >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z0, z1'')), 1 + (1 + (1 + z1''))), 1 + (1 + (1 + z1''))) + DIV(0, 1 + (1 + (1 + z1''))) + MINUS(z0, 1 + z1'') :|: z' = 1 + (1 + (1 + z1'')), z0 >= 0, z = 1 + (1 + z0), z1'' >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + z0'', z1'')), 1 + (1 + (1 + z1''))), 1 + (1 + (1 + z1''))) + DIV(minus(z0'', z1''), 1 + (1 + (1 + z1''))) + MINUS(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + (1 + z1'')), z = 1 + (1 + (1 + z0'')), z0'' >= 0, z1'' >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z0', z1'), 1 + (1 + (1 + z1'))), 1 + (1 + (1 + z1'))) + DIV(p(minus(1 + z0', z1')), 1 + (1 + (1 + z1'))) + MINUS(1 + z0', 1 + z1') :|: z0' >= 0, z1' >= 0, z = 1 + (1 + (1 + z0')), z' = 1 + (1 + (1 + z1'))
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z0', z1'), 1 + (1 + (1 + z1'))), 1 + (1 + (1 + z1'))) + DIV(minus(z0', z1'), 1 + (1 + (1 + z1'))) + MINUS(1 + z0', 1 + z1') :|: z0' >= 0, z1' >= 0, z = 1 + (1 + (1 + z0')), z' = 1 + (1 + (1 + z1'))
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z0', z1'), 1 + (1 + (1 + z1'))), 1 + (1 + (1 + z1'))) + DIV(0, 1 + (1 + (1 + z1'))) + MINUS(1 + z0', 1 + z1') :|: z0' >= 0, z1' >= 0, z = 1 + (1 + (1 + z0')), z' = 1 + (1 + (1 + z1'))
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + z1)), 1 + (1 + z1)) + DIV(0, 1 + (1 + z1)) + MINUS(z0, z1) :|: z' = 1 + (1 + z1), z1 >= 0, z0 >= 0, z = 1 + (1 + z0)
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z0, 1 + (1 + 0)) + MINUS(z0, 0) :|: z' = 1 + (1 + 0), z0 >= 0, z = 1 + (1 + z0)
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + z11))), 1 + (1 + (1 + z11))) + DIV(minus(z01, z11), 1 + (1 + (1 + z11))) + MINUS(1 + z01, 1 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + (1 + (1 + z01)), z' = 1 + (1 + (1 + z11))
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + z12))), 1 + (1 + (1 + z12))) + DIV(p(minus(z0, z12)), 1 + (1 + (1 + z12))) + MINUS(z0, 1 + z12) :|: z' = 1 + (1 + (1 + z12)), z0 >= 0, z12 >= 0, z = 1 + (1 + z0)
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z0, z1) :|: z = z0, z1 >= 0, z0 >= 0, z' = 1 + z1
   div(z, z') -{ 0 }-> 0 :|: z0 >= 0, z' = 1 + z0, z = 0
   div(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + z0, z1)), 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   div(z, z') -{ 0 }-> 1 + div(minus(z0, z1), 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   div(z, z') -{ 0 }-> 1 + div(0, 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   minus(z, z') -{ 0 }-> z0 :|: z = z0, z0 >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(z0) :|: z = z0, z' = 1 + 0, z0 >= 0
   minus(z, z') -{ 0 }-> p(p(minus(z0, z14))) :|: z' = 1 + (1 + z14), z = z0, z0 >= 0, z14 >= 0
   minus(z, z') -{ 0 }-> p(minus(z02, z13)) :|: z' = 1 + (1 + z13), z = 1 + z02, z02 >= 0, z13 >= 0
   minus(z, z') -{ 0 }-> p(0) :|: z = z0, z1 >= 0, z0 >= 0, z' = 1 + z1
   minus(z, z') -{ 0 }-> minus(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   minus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   p(z) -{ 0 }-> z0 :|: z = 1 + z0, z0 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0


----------------------------------------

(45) InliningProof (UPPER BOUND(ID))
Inlined the following terminating rules on right-hand sides where appropriate:

   p(z) -{ 0 }-> z0 :|: z = 1 + z0, z0 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0

----------------------------------------

(46)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + z0, z1)), 1 + z1) + MINUS(1 + z0, 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z0, z1), 1 + z1) + MINUS(1 + z0, 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + z1) + MINUS(1 + z0, 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z0, 1 + (1 + 0)) + MINUS(z0, 0) :|: z' = 1 + (1 + 0), z0 >= 0, z = 1 + (1 + z0)
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z0, 0) :|: z' = 1 + (1 + 0), z0 >= 0, z = 1 + (1 + z0)
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z0, z1'')), 1 + (1 + (1 + z1''))), 1 + (1 + (1 + z1''))) + DIV(p(minus(z0, z1'')), 1 + (1 + (1 + z1''))) + MINUS(z0, 1 + z1'') :|: z' = 1 + (1 + (1 + z1'')), z0 >= 0, z = 1 + (1 + z0), z1'' >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z0, z1'')), 1 + (1 + (1 + z1''))), 1 + (1 + (1 + z1''))) + DIV(0, 1 + (1 + (1 + z1''))) + MINUS(z0, 1 + z1'') :|: z' = 1 + (1 + (1 + z1'')), z0 >= 0, z = 1 + (1 + z0), z1'' >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + z0'', z1'')), 1 + (1 + (1 + z1''))), 1 + (1 + (1 + z1''))) + DIV(minus(z0'', z1''), 1 + (1 + (1 + z1''))) + MINUS(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + (1 + z1'')), z = 1 + (1 + (1 + z0'')), z0'' >= 0, z1'' >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z0', z1'), 1 + (1 + (1 + z1'))), 1 + (1 + (1 + z1'))) + DIV(p(minus(1 + z0', z1')), 1 + (1 + (1 + z1'))) + MINUS(1 + z0', 1 + z1') :|: z0' >= 0, z1' >= 0, z = 1 + (1 + (1 + z0')), z' = 1 + (1 + (1 + z1'))
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z0', z1'), 1 + (1 + (1 + z1'))), 1 + (1 + (1 + z1'))) + DIV(minus(z0', z1'), 1 + (1 + (1 + z1'))) + MINUS(1 + z0', 1 + z1') :|: z0' >= 0, z1' >= 0, z = 1 + (1 + (1 + z0')), z' = 1 + (1 + (1 + z1'))
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z0', z1'), 1 + (1 + (1 + z1'))), 1 + (1 + (1 + z1'))) + DIV(0, 1 + (1 + (1 + z1'))) + MINUS(1 + z0', 1 + z1') :|: z0' >= 0, z1' >= 0, z = 1 + (1 + (1 + z0')), z' = 1 + (1 + (1 + z1'))
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + z1)), 1 + (1 + z1)) + DIV(0, 1 + (1 + z1)) + MINUS(z0, z1) :|: z' = 1 + (1 + z1), z1 >= 0, z0 >= 0, z = 1 + (1 + z0)
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z0, 1 + (1 + 0)) + MINUS(z0, 0) :|: z' = 1 + (1 + 0), z0 >= 0, z = 1 + (1 + z0)
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + z11))), 1 + (1 + (1 + z11))) + DIV(minus(z01, z11), 1 + (1 + (1 + z11))) + MINUS(1 + z01, 1 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + (1 + (1 + z01)), z' = 1 + (1 + (1 + z11))
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + z12))), 1 + (1 + (1 + z12))) + DIV(p(minus(z0, z12)), 1 + (1 + (1 + z12))) + MINUS(z0, 1 + z12) :|: z' = 1 + (1 + (1 + z12)), z0 >= 0, z12 >= 0, z = 1 + (1 + z0)
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z0, z1) :|: z = z0, z1 >= 0, z0 >= 0, z' = 1 + z1
   div(z, z') -{ 0 }-> 0 :|: z0 >= 0, z' = 1 + z0, z = 0
   div(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + z0, z1)), 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   div(z, z') -{ 0 }-> 1 + div(minus(z0, z1), 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   div(z, z') -{ 0 }-> 1 + div(0, 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   minus(z, z') -{ 0 }-> z0 :|: z = z0, z0 >= 0, z' = 0
   minus(z, z') -{ 0 }-> z0' :|: z = z0, z' = 1 + 0, z0 >= 0, z0 = 1 + z0', z0' >= 0
   minus(z, z') -{ 0 }-> p(p(minus(z0, z14))) :|: z' = 1 + (1 + z14), z = z0, z0 >= 0, z14 >= 0
   minus(z, z') -{ 0 }-> p(minus(z02, z13)) :|: z' = 1 + (1 + z13), z = 1 + z02, z02 >= 0, z13 >= 0
   minus(z, z') -{ 0 }-> minus(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   minus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   minus(z, z') -{ 0 }-> 0 :|: z = z0, z' = 1 + 0, z0 >= 0, z0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z = z0, z' = 1 + 0, z0 >= 0, v0 >= 0, z0 = v0
   minus(z, z') -{ 0 }-> 0 :|: z = z0, z1 >= 0, z0 >= 0, z' = 1 + z1, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z = z0, z1 >= 0, z0 >= 0, z' = 1 + z1, v0 >= 0, 0 = v0
   p(z) -{ 0 }-> z0 :|: z = 1 + z0, z0 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0


----------------------------------------

(47) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(48)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + MINUS(z - 2, z' - 2) :|: z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z, z' - 1) :|: z' - 1 >= 0, z >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0


----------------------------------------

(49) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID))
Found the following analysis order by SCC decomposition:

   { p }
   { MINUS }
   { minus }
   { div }
   { DIV }
   { LOG }

----------------------------------------

(50)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + MINUS(z - 2, z' - 2) :|: z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z, z' - 1) :|: z' - 1 >= 0, z >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {p}, {MINUS}, {minus}, {div}, {DIV}, {LOG}

----------------------------------------

(51) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(52)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + MINUS(z - 2, z' - 2) :|: z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z, z' - 1) :|: z' - 1 >= 0, z >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {p}, {MINUS}, {minus}, {div}, {DIV}, {LOG}

----------------------------------------

(53) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: p
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z

----------------------------------------

(54)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + MINUS(z - 2, z' - 2) :|: z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z, z' - 1) :|: z' - 1 >= 0, z >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {p}, {MINUS}, {minus}, {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: ?, size: O(n^1) [z]

----------------------------------------

(55) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: p
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

----------------------------------------

(56)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + MINUS(z - 2, z' - 2) :|: z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z, z' - 1) :|: z' - 1 >= 0, z >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {MINUS}, {minus}, {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]

----------------------------------------

(57) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(58)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + MINUS(z - 2, z' - 2) :|: z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z, z' - 1) :|: z' - 1 >= 0, z >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {MINUS}, {minus}, {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]

----------------------------------------

(59) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: MINUS
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

----------------------------------------

(60)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + MINUS(z - 2, z' - 2) :|: z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z, z' - 1) :|: z' - 1 >= 0, z >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {MINUS}, {minus}, {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: ?, size: O(1) [0]

----------------------------------------

(61) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: MINUS
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z'

----------------------------------------

(62)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 }-> 1 + DIV(0, 1 + (z' - 1)) + MINUS(1 + (z - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + MINUS(z - 2, z' - 2) :|: z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + MINUS(z - 2, 1 + (z' - 3)) :|: z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + MINUS(1 + (z - 3), 1 + (z' - 3)) :|: z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + MINUS(z - 2, 0) :|: z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z, z' - 1) :|: z' - 1 >= 0, z >= 0
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {minus}, {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]

----------------------------------------

(63) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(64)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 + z' }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + s9 :|: s9 >= 0, s9 <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + s' :|: s' >= 0, s' <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(0, 1 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + s12 :|: s12 >= 0, s12 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s13 :|: s13 >= 0, s13 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + s11 :|: s11 >= 0, s11 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + s10 :|: s10 >= 0, s10 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + s1 :|: s1 >= 0, s1 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s2 :|: s2 >= 0, s2 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s6 :|: s6 >= 0, s6 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + s7 :|: s7 >= 0, s7 <= 0, z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + s14 :|: s14 >= 0, s14 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + s5 :|: s5 >= 0, s5 <= 0, z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + s4 :|: s4 >= 0, s4 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s3 :|: s3 >= 0, s3 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   MINUS(z, z') -{ z' }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z' - 1 >= 0, z >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {minus}, {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]

----------------------------------------

(65) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: minus
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z

----------------------------------------

(66)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 + z' }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + s9 :|: s9 >= 0, s9 <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + s' :|: s' >= 0, s' <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(0, 1 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + s12 :|: s12 >= 0, s12 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s13 :|: s13 >= 0, s13 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + s11 :|: s11 >= 0, s11 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + s10 :|: s10 >= 0, s10 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + s1 :|: s1 >= 0, s1 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s2 :|: s2 >= 0, s2 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s6 :|: s6 >= 0, s6 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + s7 :|: s7 >= 0, s7 <= 0, z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + s14 :|: s14 >= 0, s14 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + s5 :|: s5 >= 0, s5 <= 0, z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + s4 :|: s4 >= 0, s4 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s3 :|: s3 >= 0, s3 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   MINUS(z, z') -{ z' }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z' - 1 >= 0, z >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {minus}, {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]
  minus: runtime: ?, size: O(n^1) [z]

----------------------------------------

(67) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: minus
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

----------------------------------------

(68)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 + z' }-> 1 + DIV(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) + s9 :|: s9 >= 0, s9 <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(minus(z - 1, z' - 1), 1 + (z' - 1)) + s' :|: s' >= 0, s' <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(0, 1 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + s12 :|: s12 >= 0, s12 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s13 :|: s13 >= 0, s13 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + s11 :|: s11 >= 0, s11 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(1 + (z - 3), z' - 3)), 1 + (1 + (1 + (z' - 3)))) + s10 :|: s10 >= 0, s10 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + s1 :|: s1 >= 0, s1 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s2 :|: s2 >= 0, s2 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s6 :|: s6 >= 0, s6 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + s7 :|: s7 >= 0, s7 <= 0, z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))) + s14 :|: s14 >= 0, s14 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))) + s5 :|: s5 >= 0, s5 <= 0, z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + s4 :|: s4 >= 0, s4 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s3 :|: s3 >= 0, s3 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   MINUS(z, z') -{ z' }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z' - 1 >= 0, z >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> minus(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]
  minus: runtime: O(1) [0], size: O(n^1) [z]

----------------------------------------

(69) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(70)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s15, 1 + (z' - 1)) + s' :|: s15 >= 0, s15 <= z - 1, s' >= 0, s' <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s23, 1 + (z' - 1)) + s9 :|: s22 >= 0, s22 <= 1 + (z - 1), s23 >= 0, s23 <= s22, s9 >= 0, s9 <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(0, 1 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s16, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s17, 1 + (1 + (1 + (z' - 3)))) + s1 :|: s16 >= 0, s16 <= z - 3, s17 >= 0, s17 <= z - 3, s1 >= 0, s1 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s18, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s2 :|: s18 >= 0, s18 <= z - 3, s2 >= 0, s2 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s24, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s26, 1 + (1 + (1 + (z' - 3)))) + s10 :|: s24 >= 0, s24 <= z - 3, s25 >= 0, s25 <= 1 + (z - 3), s26 >= 0, s26 <= s25, s10 >= 0, s10 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s28, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s29, 1 + (1 + (1 + (z' - 3)))) + s11 :|: s27 >= 0, s27 <= 1 + (z - 3), s28 >= 0, s28 <= s27, s29 >= 0, s29 <= z - 3, s11 >= 0, s11 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s31, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s33, 1 + (1 + (1 + (z' - 3)))) + s12 :|: s30 >= 0, s30 <= z - 2, s31 >= 0, s31 <= s30, s32 >= 0, s32 <= z - 2, s33 >= 0, s33 <= s32, s12 >= 0, s12 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s35, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s13 :|: s34 >= 0, s34 <= z - 2, s35 >= 0, s35 <= s34, s13 >= 0, s13 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s6 :|: s6 >= 0, s6 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + s7 :|: s7 >= 0, s7 <= 0, z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s19, 1 + (1 + (1 + (z' - 3)))) + s5 :|: s19 >= 0, s19 <= z - 3, s5 >= 0, s5 <= 0, z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s37, 1 + (1 + (1 + (z' - 3)))) + s14 :|: s36 >= 0, s36 <= z - 2, s37 >= 0, s37 <= s36, s14 >= 0, s14 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + s4 :|: s4 >= 0, s4 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s3 :|: s3 >= 0, s3 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   MINUS(z, z') -{ z' }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z' - 1 >= 0, z >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(s21, 1 + (z' - 1)) :|: s21 >= 0, s21 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(s44, 1 + (z' - 1)) :|: s43 >= 0, s43 <= 1 + (z - 1), s44 >= 0, s44 <= s43, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s39 :|: s38 >= 0, s38 <= z - 1, s39 >= 0, s39 <= s38, z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= z, s41 >= 0, s41 <= s40, s42 >= 0, s42 <= s41, z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]
  minus: runtime: O(1) [0], size: O(n^1) [z]

----------------------------------------

(71) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: div
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

----------------------------------------

(72)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s15, 1 + (z' - 1)) + s' :|: s15 >= 0, s15 <= z - 1, s' >= 0, s' <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s23, 1 + (z' - 1)) + s9 :|: s22 >= 0, s22 <= 1 + (z - 1), s23 >= 0, s23 <= s22, s9 >= 0, s9 <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(0, 1 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s16, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s17, 1 + (1 + (1 + (z' - 3)))) + s1 :|: s16 >= 0, s16 <= z - 3, s17 >= 0, s17 <= z - 3, s1 >= 0, s1 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s18, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s2 :|: s18 >= 0, s18 <= z - 3, s2 >= 0, s2 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s24, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s26, 1 + (1 + (1 + (z' - 3)))) + s10 :|: s24 >= 0, s24 <= z - 3, s25 >= 0, s25 <= 1 + (z - 3), s26 >= 0, s26 <= s25, s10 >= 0, s10 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s28, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s29, 1 + (1 + (1 + (z' - 3)))) + s11 :|: s27 >= 0, s27 <= 1 + (z - 3), s28 >= 0, s28 <= s27, s29 >= 0, s29 <= z - 3, s11 >= 0, s11 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s31, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s33, 1 + (1 + (1 + (z' - 3)))) + s12 :|: s30 >= 0, s30 <= z - 2, s31 >= 0, s31 <= s30, s32 >= 0, s32 <= z - 2, s33 >= 0, s33 <= s32, s12 >= 0, s12 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s35, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s13 :|: s34 >= 0, s34 <= z - 2, s35 >= 0, s35 <= s34, s13 >= 0, s13 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s6 :|: s6 >= 0, s6 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + s7 :|: s7 >= 0, s7 <= 0, z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s19, 1 + (1 + (1 + (z' - 3)))) + s5 :|: s19 >= 0, s19 <= z - 3, s5 >= 0, s5 <= 0, z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s37, 1 + (1 + (1 + (z' - 3)))) + s14 :|: s36 >= 0, s36 <= z - 2, s37 >= 0, s37 <= s36, s14 >= 0, s14 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + s4 :|: s4 >= 0, s4 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s3 :|: s3 >= 0, s3 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   MINUS(z, z') -{ z' }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z' - 1 >= 0, z >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(s21, 1 + (z' - 1)) :|: s21 >= 0, s21 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(s44, 1 + (z' - 1)) :|: s43 >= 0, s43 <= 1 + (z - 1), s44 >= 0, s44 <= s43, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s39 :|: s38 >= 0, s38 <= z - 1, s39 >= 0, s39 <= s38, z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= z, s41 >= 0, s41 <= s40, s42 >= 0, s42 <= s41, z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {div}, {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]
  minus: runtime: O(1) [0], size: O(n^1) [z]
  div: runtime: ?, size: INF

----------------------------------------

(73) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: div
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

----------------------------------------

(74)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s15, 1 + (z' - 1)) + s' :|: s15 >= 0, s15 <= z - 1, s' >= 0, s' <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s23, 1 + (z' - 1)) + s9 :|: s22 >= 0, s22 <= 1 + (z - 1), s23 >= 0, s23 <= s22, s9 >= 0, s9 <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(0, 1 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s16, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s17, 1 + (1 + (1 + (z' - 3)))) + s1 :|: s16 >= 0, s16 <= z - 3, s17 >= 0, s17 <= z - 3, s1 >= 0, s1 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s18, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s2 :|: s18 >= 0, s18 <= z - 3, s2 >= 0, s2 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s24, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s26, 1 + (1 + (1 + (z' - 3)))) + s10 :|: s24 >= 0, s24 <= z - 3, s25 >= 0, s25 <= 1 + (z - 3), s26 >= 0, s26 <= s25, s10 >= 0, s10 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s28, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s29, 1 + (1 + (1 + (z' - 3)))) + s11 :|: s27 >= 0, s27 <= 1 + (z - 3), s28 >= 0, s28 <= s27, s29 >= 0, s29 <= z - 3, s11 >= 0, s11 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s31, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s33, 1 + (1 + (1 + (z' - 3)))) + s12 :|: s30 >= 0, s30 <= z - 2, s31 >= 0, s31 <= s30, s32 >= 0, s32 <= z - 2, s33 >= 0, s33 <= s32, s12 >= 0, s12 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(s35, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s13 :|: s34 >= 0, s34 <= z - 2, s35 >= 0, s35 <= s34, s13 >= 0, s13 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(0, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s6 :|: s6 >= 0, s6 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (z' - 2))), 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + s7 :|: s7 >= 0, s7 <= 0, z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s19, 1 + (1 + (1 + (z' - 3)))) + s5 :|: s19 >= 0, s19 <= z - 3, s5 >= 0, s5 <= 0, z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(div(0, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) + DIV(s37, 1 + (1 + (1 + (z' - 3)))) + s14 :|: s36 >= 0, s36 <= z - 2, s37 >= 0, s37 <= s36, s14 >= 0, s14 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + s4 :|: s4 >= 0, s4 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s3 :|: s3 >= 0, s3 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   MINUS(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   MINUS(z, z') -{ z' }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z' - 1 >= 0, z >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + div(s21, 1 + (z' - 1)) :|: s21 >= 0, s21 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(s44, 1 + (z' - 1)) :|: s43 >= 0, s43 <= 1 + (z - 1), s44 >= 0, s44 <= s43, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + div(0, 1 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s39 :|: s38 >= 0, s38 <= z - 1, s39 >= 0, s39 <= s38, z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= z, s41 >= 0, s41 <= s40, s42 >= 0, s42 <= s41, z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]
  minus: runtime: O(1) [0], size: O(n^1) [z]
  div: runtime: O(1) [0], size: INF

----------------------------------------

(75) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(76)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s15, 1 + (z' - 1)) + s' :|: s15 >= 0, s15 <= z - 1, s' >= 0, s' <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s23, 1 + (z' - 1)) + s9 :|: s22 >= 0, s22 <= 1 + (z - 1), s23 >= 0, s23 <= s22, s9 >= 0, s9 <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(0, 1 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s45, 1 + (1 + (1 + (z' - 3)))) + DIV(s17, 1 + (1 + (1 + (z' - 3)))) + s1 :|: s45 >= 0, s45 <= inf, s16 >= 0, s16 <= z - 3, s17 >= 0, s17 <= z - 3, s1 >= 0, s1 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s46, 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s2 :|: s46 >= 0, s46 <= inf', s18 >= 0, s18 <= z - 3, s2 >= 0, s2 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(s47, 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s3 :|: s47 >= 0, s47 <= inf'', s3 >= 0, s3 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(s48, 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + s4 :|: s48 >= 0, s48 <= inf1, s4 >= 0, s4 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s49, 1 + (1 + (1 + (z' - 3)))) + DIV(s19, 1 + (1 + (1 + (z' - 3)))) + s5 :|: s49 >= 0, s49 <= inf2, s19 >= 0, s19 <= z - 3, s5 >= 0, s5 <= 0, z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(s50, 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s6 :|: s50 >= 0, s50 <= inf3, s6 >= 0, s6 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s51, 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + s7 :|: s51 >= 0, s51 <= inf4, s7 >= 0, s7 <= 0, z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s54, 1 + (1 + (1 + (z' - 3)))) + DIV(s26, 1 + (1 + (1 + (z' - 3)))) + s10 :|: s54 >= 0, s54 <= inf7, s24 >= 0, s24 <= z - 3, s25 >= 0, s25 <= 1 + (z - 3), s26 >= 0, s26 <= s25, s10 >= 0, s10 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s55, 1 + (1 + (1 + (z' - 3)))) + DIV(s29, 1 + (1 + (1 + (z' - 3)))) + s11 :|: s55 >= 0, s55 <= inf8, s27 >= 0, s27 <= 1 + (z - 3), s28 >= 0, s28 <= s27, s29 >= 0, s29 <= z - 3, s11 >= 0, s11 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s56, 1 + (1 + (1 + (z' - 3)))) + DIV(s33, 1 + (1 + (1 + (z' - 3)))) + s12 :|: s56 >= 0, s56 <= inf9, s30 >= 0, s30 <= z - 2, s31 >= 0, s31 <= s30, s32 >= 0, s32 <= z - 2, s33 >= 0, s33 <= s32, s12 >= 0, s12 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s57, 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s13 :|: s57 >= 0, s57 <= inf10, s34 >= 0, s34 <= z - 2, s35 >= 0, s35 <= s34, s13 >= 0, s13 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s58, 1 + (1 + (1 + (z' - 3)))) + DIV(s37, 1 + (1 + (1 + (z' - 3)))) + s14 :|: s58 >= 0, s58 <= inf11, s36 >= 0, s36 <= z - 2, s37 >= 0, s37 <= s36, s14 >= 0, s14 <= 0, z - 2 >= 0, z' - 3 >= 0
   MINUS(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   MINUS(z, z') -{ z' }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z' - 1 >= 0, z >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + s52 :|: s52 >= 0, s52 <= inf5, s21 >= 0, s21 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + s53 :|: s53 >= 0, s53 <= inf6, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + s59 :|: s59 >= 0, s59 <= inf12, s43 >= 0, s43 <= 1 + (z - 1), s44 >= 0, s44 <= s43, z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s39 :|: s38 >= 0, s38 <= z - 1, s39 >= 0, s39 <= s38, z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= z, s41 >= 0, s41 <= s40, s42 >= 0, s42 <= s41, z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]
  minus: runtime: O(1) [0], size: O(n^1) [z]
  div: runtime: O(1) [0], size: INF

----------------------------------------

(77) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: DIV
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

----------------------------------------

(78)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s15, 1 + (z' - 1)) + s' :|: s15 >= 0, s15 <= z - 1, s' >= 0, s' <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s23, 1 + (z' - 1)) + s9 :|: s22 >= 0, s22 <= 1 + (z - 1), s23 >= 0, s23 <= s22, s9 >= 0, s9 <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(0, 1 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s45, 1 + (1 + (1 + (z' - 3)))) + DIV(s17, 1 + (1 + (1 + (z' - 3)))) + s1 :|: s45 >= 0, s45 <= inf, s16 >= 0, s16 <= z - 3, s17 >= 0, s17 <= z - 3, s1 >= 0, s1 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s46, 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s2 :|: s46 >= 0, s46 <= inf', s18 >= 0, s18 <= z - 3, s2 >= 0, s2 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(s47, 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s3 :|: s47 >= 0, s47 <= inf'', s3 >= 0, s3 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(s48, 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + s4 :|: s48 >= 0, s48 <= inf1, s4 >= 0, s4 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s49, 1 + (1 + (1 + (z' - 3)))) + DIV(s19, 1 + (1 + (1 + (z' - 3)))) + s5 :|: s49 >= 0, s49 <= inf2, s19 >= 0, s19 <= z - 3, s5 >= 0, s5 <= 0, z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(s50, 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s6 :|: s50 >= 0, s50 <= inf3, s6 >= 0, s6 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s51, 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + s7 :|: s51 >= 0, s51 <= inf4, s7 >= 0, s7 <= 0, z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s54, 1 + (1 + (1 + (z' - 3)))) + DIV(s26, 1 + (1 + (1 + (z' - 3)))) + s10 :|: s54 >= 0, s54 <= inf7, s24 >= 0, s24 <= z - 3, s25 >= 0, s25 <= 1 + (z - 3), s26 >= 0, s26 <= s25, s10 >= 0, s10 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s55, 1 + (1 + (1 + (z' - 3)))) + DIV(s29, 1 + (1 + (1 + (z' - 3)))) + s11 :|: s55 >= 0, s55 <= inf8, s27 >= 0, s27 <= 1 + (z - 3), s28 >= 0, s28 <= s27, s29 >= 0, s29 <= z - 3, s11 >= 0, s11 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s56, 1 + (1 + (1 + (z' - 3)))) + DIV(s33, 1 + (1 + (1 + (z' - 3)))) + s12 :|: s56 >= 0, s56 <= inf9, s30 >= 0, s30 <= z - 2, s31 >= 0, s31 <= s30, s32 >= 0, s32 <= z - 2, s33 >= 0, s33 <= s32, s12 >= 0, s12 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s57, 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s13 :|: s57 >= 0, s57 <= inf10, s34 >= 0, s34 <= z - 2, s35 >= 0, s35 <= s34, s13 >= 0, s13 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s58, 1 + (1 + (1 + (z' - 3)))) + DIV(s37, 1 + (1 + (1 + (z' - 3)))) + s14 :|: s58 >= 0, s58 <= inf11, s36 >= 0, s36 <= z - 2, s37 >= 0, s37 <= s36, s14 >= 0, s14 <= 0, z - 2 >= 0, z' - 3 >= 0
   MINUS(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   MINUS(z, z') -{ z' }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z' - 1 >= 0, z >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + s52 :|: s52 >= 0, s52 <= inf5, s21 >= 0, s21 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + s53 :|: s53 >= 0, s53 <= inf6, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + s59 :|: s59 >= 0, s59 <= inf12, s43 >= 0, s43 <= 1 + (z - 1), s44 >= 0, s44 <= s43, z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s39 :|: s38 >= 0, s38 <= z - 1, s39 >= 0, s39 <= s38, z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= z, s41 >= 0, s41 <= s40, s42 >= 0, s42 <= s41, z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]
  minus: runtime: O(1) [0], size: O(n^1) [z]
  div: runtime: O(1) [0], size: INF
  DIV: runtime: ?, size: O(1) [0]

----------------------------------------

(79) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: DIV
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

----------------------------------------

(80)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s15, 1 + (z' - 1)) + s' :|: s15 >= 0, s15 <= z - 1, s' >= 0, s' <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(s23, 1 + (z' - 1)) + s9 :|: s22 >= 0, s22 <= 1 + (z - 1), s23 >= 0, s23 <= s22, s9 >= 0, s9 <= 0, z' - 1 >= 0, z - 1 >= 0
   DIV(z, z') -{ 1 + z' }-> 1 + DIV(0, 1 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s45, 1 + (1 + (1 + (z' - 3)))) + DIV(s17, 1 + (1 + (1 + (z' - 3)))) + s1 :|: s45 >= 0, s45 <= inf, s16 >= 0, s16 <= z - 3, s17 >= 0, s17 <= z - 3, s1 >= 0, s1 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s46, 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s2 :|: s46 >= 0, s46 <= inf', s18 >= 0, s18 <= z - 3, s2 >= 0, s2 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(s47, 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s3 :|: s47 >= 0, s47 <= inf'', s3 >= 0, s3 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(s48, 1 + (1 + 0)) + DIV(0, 1 + (1 + 0)) + s4 :|: s48 >= 0, s48 <= inf1, s4 >= 0, s4 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s49, 1 + (1 + (1 + (z' - 3)))) + DIV(s19, 1 + (1 + (1 + (z' - 3)))) + s5 :|: s49 >= 0, s49 <= inf2, s19 >= 0, s19 <= z - 3, s5 >= 0, s5 <= 0, z' - 3 >= 0, z - 3 >= 0
   LOG(z, z') -{ 1 }-> 1 + LOG(s50, 1 + (1 + 0)) + DIV(z - 2, 1 + (1 + 0)) + s6 :|: s50 >= 0, s50 <= inf3, s6 >= 0, s6 <= 0, z' = 1 + (1 + 0), z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s51, 1 + (1 + (z' - 2))) + DIV(0, 1 + (1 + (z' - 2))) + s7 :|: s51 >= 0, s51 <= inf4, s7 >= 0, s7 <= 0, z' - 2 >= 0, z - 2 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s54, 1 + (1 + (1 + (z' - 3)))) + DIV(s26, 1 + (1 + (1 + (z' - 3)))) + s10 :|: s54 >= 0, s54 <= inf7, s24 >= 0, s24 <= z - 3, s25 >= 0, s25 <= 1 + (z - 3), s26 >= 0, s26 <= s25, s10 >= 0, s10 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s55, 1 + (1 + (1 + (z' - 3)))) + DIV(s29, 1 + (1 + (1 + (z' - 3)))) + s11 :|: s55 >= 0, s55 <= inf8, s27 >= 0, s27 <= 1 + (z - 3), s28 >= 0, s28 <= s27, s29 >= 0, s29 <= z - 3, s11 >= 0, s11 <= 0, z - 3 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s56, 1 + (1 + (1 + (z' - 3)))) + DIV(s33, 1 + (1 + (1 + (z' - 3)))) + s12 :|: s56 >= 0, s56 <= inf9, s30 >= 0, s30 <= z - 2, s31 >= 0, s31 <= s30, s32 >= 0, s32 <= z - 2, s33 >= 0, s33 <= s32, s12 >= 0, s12 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s57, 1 + (1 + (1 + (z' - 3)))) + DIV(0, 1 + (1 + (1 + (z' - 3)))) + s13 :|: s57 >= 0, s57 <= inf10, s34 >= 0, s34 <= z - 2, s35 >= 0, s35 <= s34, s13 >= 0, s13 <= 0, z - 2 >= 0, z' - 3 >= 0
   LOG(z, z') -{ -1 + z' }-> 1 + LOG(s58, 1 + (1 + (1 + (z' - 3)))) + DIV(s37, 1 + (1 + (1 + (z' - 3)))) + s14 :|: s58 >= 0, s58 <= inf11, s36 >= 0, s36 <= z - 2, s37 >= 0, s37 <= s36, s14 >= 0, s14 <= 0, z - 2 >= 0, z' - 3 >= 0
   MINUS(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   MINUS(z, z') -{ z' }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z' - 1 >= 0, z >= 0
   div(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 0 }-> 1 + s52 :|: s52 >= 0, s52 <= inf5, s21 >= 0, s21 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + s53 :|: s53 >= 0, s53 <= inf6, z' - 1 >= 0, z - 1 >= 0
   div(z, z') -{ 0 }-> 1 + s59 :|: s59 >= 0, s59 <= inf12, s43 >= 0, s43 <= 1 + (z - 1), s44 >= 0, s44 <= s43, z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z - 1, z' - 1 >= 0, z - 1 >= 0
   minus(z, z') -{ 0 }-> s39 :|: s38 >= 0, s38 <= z - 1, s39 >= 0, s39 <= s38, z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> s42 :|: s40 >= 0, s40 <= z, s41 >= 0, s41 <= s40, s42 >= 0, s42 <= s41, z >= 0, z' - 2 >= 0
   minus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0, z = 0
   minus(z, z') -{ 0 }-> 0 :|: z' = 1 + 0, z >= 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, 0 = 0
   minus(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z >= 0, v0 >= 0, 0 = v0
   minus(z, z') -{ 0 }-> z - 1 :|: z' = 1 + 0, z >= 0, z - 1 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: z >= 0
   p(z) -{ 0 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {DIV}, {LOG}
Previous analysis results are:
  p: runtime: O(1) [0], size: O(n^1) [z]
  MINUS: runtime: O(n^1) [z'], size: O(1) [0]
  minus: runtime: O(1) [0], size: O(n^1) [z]
  div: runtime: O(1) [0], size: INF
  DIV: runtime: INF, size: O(1) [0]

----------------------------------------

(81) CompletionProof (UPPER BOUND(ID))
The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added:

   minus(v0, v1) -> null_minus [0]
   p(v0) -> null_p [0]
   div(v0, v1) -> null_div [0]
   MINUS(v0, v1) -> null_MINUS [0]
   DIV(v0, v1) -> null_DIV [0]
   LOG(v0, v1) -> null_LOG [0]

And the following fresh constants:    null_minus, null_p, null_div, null_MINUS, null_DIV, null_LOG

----------------------------------------

(82)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1)) [1]
   DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1))) [1]
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1)) [1]
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1)) [1]
   minus(s(z0), s(z1)) -> minus(z0, z1) [0]
   minus(z0, s(z1)) -> p(minus(z0, z1)) [0]
   minus(z0, 0) -> z0 [0]
   p(0) -> 0 [0]
   p(s(z0)) -> z0 [0]
   div(0, s(z0)) -> 0 [0]
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1))) [0]
   minus(v0, v1) -> null_minus [0]
   p(v0) -> null_p [0]
   div(v0, v1) -> null_div [0]
   MINUS(v0, v1) -> null_MINUS [0]
   DIV(v0, v1) -> null_DIV [0]
   LOG(v0, v1) -> null_LOG [0]

The TRS has the following type information:
MINUS :: s:0:null_minus:null_p:null_div -> s:0:null_minus:null_p:null_div -> c3:c4:null_MINUS
s :: s:0:null_minus:null_p:null_div -> s:0:null_minus:null_p:null_div
c3 :: c3:c4:null_MINUS -> c3:c4:null_MINUS
DIV :: s:0:null_minus:null_p:null_div -> s:0:null_minus:null_p:null_div -> c6:null_DIV
c6 :: c6:null_DIV -> c3:c4:null_MINUS -> c6:null_DIV
minus :: s:0:null_minus:null_p:null_div -> s:0:null_minus:null_p:null_div -> s:0:null_minus:null_p:null_div
LOG :: s:0:null_minus:null_p:null_div -> s:0:null_minus:null_p:null_div -> c8:null_LOG
c8 :: c8:null_LOG -> c6:null_DIV -> c3:c4:null_MINUS -> c8:null_LOG
div :: s:0:null_minus:null_p:null_div -> s:0:null_minus:null_p:null_div -> s:0:null_minus:null_p:null_div
c4 :: c3:c4:null_MINUS -> c3:c4:null_MINUS
p :: s:0:null_minus:null_p:null_div -> s:0:null_minus:null_p:null_div
0 :: s:0:null_minus:null_p:null_div
null_minus :: s:0:null_minus:null_p:null_div
null_p :: s:0:null_minus:null_p:null_div
null_div :: s:0:null_minus:null_p:null_div
null_MINUS :: c3:c4:null_MINUS
null_DIV :: c6:null_DIV
null_LOG :: c8:null_LOG

Rewrite Strategy: INNERMOST
----------------------------------------

(83) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   null_minus => 0
   null_p => 0
   null_div => 0
   null_MINUS => 0
   null_DIV => 0
   null_LOG => 0

----------------------------------------

(84)
Obligation:
Complexity RNTS consisting of the following rules:

   DIV(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   DIV(z, z') -{ 1 }-> 1 + DIV(minus(1 + z0, 1 + z1), 1 + z1) + MINUS(1 + z0, 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   LOG(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   LOG(z, z') -{ 1 }-> 1 + LOG(div(minus(z0, z1), 1 + (1 + z1)), 1 + (1 + z1)) + DIV(minus(z0, z1), 1 + (1 + z1)) + MINUS(z0, z1) :|: z' = 1 + (1 + z1), z1 >= 0, z0 >= 0, z = 1 + (1 + z0)
   MINUS(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   MINUS(z, z') -{ 1 }-> 1 + MINUS(z0, z1) :|: z = z0, z1 >= 0, z0 >= 0, z' = 1 + z1
   div(z, z') -{ 0 }-> 0 :|: z0 >= 0, z' = 1 + z0, z = 0
   div(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   div(z, z') -{ 0 }-> 1 + div(minus(1 + z0, 1 + z1), 1 + z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   minus(z, z') -{ 0 }-> z0 :|: z = z0, z0 >= 0, z' = 0
   minus(z, z') -{ 0 }-> p(minus(z0, z1)) :|: z = z0, z1 >= 0, z0 >= 0, z' = 1 + z1
   minus(z, z') -{ 0 }-> minus(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   minus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   p(z) -{ 0 }-> z0 :|: z = 1 + z0, z0 >= 0
   p(z) -{ 0 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0

Only complete derivations are relevant for the runtime complexity.

----------------------------------------

(85) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace DIV(s(z0), s(z1)) -> c6(DIV(minus(s(z0), s(z1)), s(z1)), MINUS(s(z0), s(z1))) by 
   DIV(s(z0), s(z1)) -> c6(DIV(minus(z0, z1), s(z1)), MINUS(s(z0), s(z1)))
   DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1)))

----------------------------------------

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(z0, z1), s(z1)), MINUS(s(z0), s(z1)))
   DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(z0, z1), s(z1)), MINUS(s(z0), s(z1)))
   DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1)))
K tuples:none
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, LOG_2, DIV_2

Compound Symbols:   c3_1, c8_3, c4_1, c6_2


----------------------------------------

(87) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LOG(s(s(z0)), s(s(z1))) -> c8(LOG(div(minus(z0, z1), s(s(z1))), s(s(z1))), DIV(minus(z0, z1), s(s(z1))), MINUS(z0, z1)) by 
   LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))), MINUS(z0, 0))

----------------------------------------

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(z0, z1), s(z1)), MINUS(s(z0), s(z1)))
   DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1)))
   LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))), MINUS(z0, 0))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(z0, z1), s(z1)), MINUS(s(z0), s(z1)))
   DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1)))
   LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))), MINUS(z0, 0))
K tuples:none
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c8_3


----------------------------------------

(89) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(z0, z1), s(z1)), MINUS(s(z0), s(z1)))
   DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1)))
   LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(z0), s(z1)) -> c6(DIV(minus(z0, z1), s(z1)), MINUS(s(z0), s(z1)))
   DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1)))
   LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
K tuples:none
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c8_3, c8_2


----------------------------------------

(91) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace DIV(s(z0), s(z1)) -> c6(DIV(minus(z0, z1), s(z1)), MINUS(s(z0), s(z1))) by 
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))

----------------------------------------

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1)))
   LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1)))
   LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
K tuples:none
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c8_3, c8_2, c6_1


----------------------------------------

(93) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace DIV(s(x0), s(z1)) -> c6(DIV(p(minus(s(x0), z1)), s(z1)), MINUS(s(x0), s(z1))) by 
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))

----------------------------------------

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1)))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
K tuples:none
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, LOG_2, DIV_2

Compound Symbols:   c3_1, c4_1, c8_3, c8_2, c6_2, c6_1


----------------------------------------

(95) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LOG(s(s(s(z0))), s(s(s(z1)))) -> c8(LOG(div(minus(z0, z1), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(s(z0), s(z1)), s(s(s(z1)))), MINUS(s(z0), s(z1))) by 
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c8(DIV(minus(s(x0), s(x1)), s(s(s(x1)))), MINUS(s(x0), s(x1)))

----------------------------------------

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c8(DIV(minus(s(x0), s(x1)), s(s(s(x1)))), MINUS(s(x0), s(x1)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c8(DIV(minus(s(x0), s(x1)), s(s(s(x1)))), MINUS(s(x0), s(x1)))
K tuples:none
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, LOG_2, DIV_2

Compound Symbols:   c3_1, c4_1, c8_3, c8_2, c6_2, c6_1


----------------------------------------

(97) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
K tuples:none
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, LOG_2, DIV_2

Compound Symbols:   c3_1, c4_1, c8_3, c8_2, c6_2, c6_1, c_1


----------------------------------------

(99) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
We considered the (Usable) Rules:none
And the Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = [1]
   POL(DIV(x_1, x_2)) = 0
   POL(LOG(x_1, x_2)) = [1] + x_2
   POL(MINUS(x_1, x_2)) = 0
   POL(c(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c6(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(div(x_1, x_2)) = [1]
   POL(minus(x_1, x_2)) = [1]
   POL(p(x_1)) = [1]
   POL(s(x_1)) = [1]

----------------------------------------

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1)))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, LOG_2, DIV_2

Compound Symbols:   c3_1, c4_1, c8_3, c8_2, c6_2, c6_1, c_1


----------------------------------------

(101) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LOG(s(s(z0)), s(s(s(z1)))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(z1)))), s(s(s(z1)))), DIV(minus(z0, s(z1)), s(s(s(z1)))), MINUS(z0, s(z1))) by 
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c8(DIV(minus(x0, s(x1)), s(s(s(x1)))), MINUS(x0, s(x1)))

----------------------------------------

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c8(DIV(minus(x0, s(x1)), s(s(s(x1)))), MINUS(x0, s(x1)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c8(DIV(minus(x0, s(x1)), s(s(s(x1)))), MINUS(x0, s(x1)))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, LOG_2, DIV_2

Compound Symbols:   c3_1, c4_1, c8_2, c6_2, c6_1, c8_3, c_1


----------------------------------------

(103) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, LOG_2, DIV_2

Compound Symbols:   c3_1, c4_1, c8_2, c6_2, c6_1, c8_3, c_1, c1_1


----------------------------------------

(105) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
We considered the (Usable) Rules:none
And the Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = [1]
   POL(DIV(x_1, x_2)) = x_2
   POL(LOG(x_1, x_2)) = [1] + x_2
   POL(MINUS(x_1, x_2)) = 0
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c6(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(div(x_1, x_2)) = [1]
   POL(minus(x_1, x_2)) = [1]
   POL(p(x_1)) = [1]
   POL(s(x_1)) = 0

----------------------------------------

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0))))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, LOG_2, DIV_2

Compound Symbols:   c3_1, c4_1, c8_2, c6_2, c6_1, c8_3, c_1, c1_1


----------------------------------------

(107) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LOG(s(s(z0)), s(s(0))) -> c8(LOG(div(z0, s(s(0))), s(s(0))), DIV(minus(z0, 0), s(s(0)))) by 
   LOG(s(s(0)), s(s(0))) -> c8(LOG(0, s(s(0))), DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))

----------------------------------------

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(0)), s(s(0))) -> c8(LOG(0, s(s(0))), DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(0)), s(s(0))) -> c8(LOG(0, s(s(0))), DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c6_1, c8_3, c_1, c1_1, c8_2, c8_1


----------------------------------------

(109) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c6_1, c8_3, c_1, c1_1, c8_2, c8_1


----------------------------------------

(111) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
We considered the (Usable) Rules:none
And the Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = [1]
   POL(DIV(x_1, x_2)) = 0
   POL(LOG(x_1, x_2)) = [1] + x_2
   POL(MINUS(x_1, x_2)) = 0
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c6(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(div(x_1, x_2)) = 0
   POL(minus(x_1, x_2)) = [1]
   POL(p(x_1)) = [1]
   POL(s(x_1)) = x_1

----------------------------------------

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0)))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c6_1, c8_3, c_1, c1_1, c8_2, c8_1


----------------------------------------

(113) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace DIV(s(x0), s(0)) -> c6(DIV(p(s(x0)), s(0)), MINUS(s(x0), s(0))) by DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
----------------------------------------

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c6_1, c8_3, c_1, c1_1, c8_2, c8_1


----------------------------------------

(115) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1))) by 
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))

----------------------------------------

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c6_1, c8_3, c_1, c1_1, c8_2, c8_1


----------------------------------------

(117) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace DIV(s(x0), s(x1)) -> c6(MINUS(s(x0), s(x1))) by 
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))

----------------------------------------

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1)))))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c8_3, c_1, c1_1, c8_2, c8_1, c6_1


----------------------------------------

(119) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace LOG(s(s(s(x0))), s(s(s(x1)))) -> c(DIV(minus(s(x0), s(x1)), s(s(s(x1))))) by 
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))

----------------------------------------

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
K tuples:
   LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c8_3, c_1, c1_1, c8_2, c8_1, c6_1


----------------------------------------

(121) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace LOG(s(s(s(x0))), s(s(s(x1)))) -> c(MINUS(s(x0), s(x1))) by 
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))

----------------------------------------

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
K tuples:
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c8_3, c1_1, c8_2, c8_1, c6_1, c_1


----------------------------------------

(123) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(minus(s(z0), 0), s(s(0)))) by LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
----------------------------------------

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
K tuples:
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1)))))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c8_3, c1_1, c8_1, c6_1, c_1, c8_2


----------------------------------------

(125) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace LOG(s(s(x0)), s(s(s(x1)))) -> c1(DIV(minus(x0, s(x1)), s(s(s(x1))))) by 
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))

----------------------------------------

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
K tuples:
   LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c8_3, c1_1, c8_1, c6_1, c_1, c8_2


----------------------------------------

(127) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace LOG(s(s(x0)), s(s(s(x1)))) -> c1(MINUS(x0, s(x1))) by 
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))

----------------------------------------

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
S tuples:
   MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1))
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
K tuples:
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c3_1, c4_1, c6_2, c8_3, c8_1, c6_1, c_1, c8_2, c1_1


----------------------------------------

(129) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MINUS(s(z0), s(z1)) -> c3(MINUS(z0, z1)) by 
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))

----------------------------------------

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
S tuples:
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
K tuples:
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c4_1, c6_2, c8_3, c8_1, c6_1, c_1, c8_2, c1_1, c3_1


----------------------------------------

(131) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0)))) by LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0))))
----------------------------------------

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0))))
S tuples:
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
K tuples:
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c4_1, c6_2, c8_3, c8_1, c6_1, c_1, c8_2, c1_1, c3_1


----------------------------------------

(133) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0)))) by LOG(s(s(0)), s(s(0))) -> c8(DIV(0, s(s(0))))
----------------------------------------

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(0, s(s(0))))
S tuples:
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
K tuples:
   LOG(s(s(x0)), s(s(0))) -> c8(DIV(minus(x0, 0), s(s(0))))
   LOG(s(s(0)), s(s(0))) -> c8(DIV(minus(0, 0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c4_1, c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1


----------------------------------------

(135) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   LOG(s(s(0)), s(s(0))) -> c8(DIV(0, s(s(0))))

----------------------------------------

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0))))
S tuples:
   MINUS(z0, s(z1)) -> c4(MINUS(z0, z1))
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   MINUS_2, DIV_2, LOG_2

Compound Symbols:   c4_1, c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1


----------------------------------------

(137) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MINUS(z0, s(z1)) -> c4(MINUS(z0, z1)) by 
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))

----------------------------------------

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0))))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1


----------------------------------------

(139) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing nodes:
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(MINUS(s(z0), s(0)))
   DIV(s(z0), s(0)) -> c6(MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(MINUS(z0, s(0)))

----------------------------------------

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0))))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)), MINUS(s(z0), s(0)))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))), MINUS(s(z0), s(0)))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))), MINUS(z0, s(0)))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1


----------------------------------------

(141) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 4 trailing tuple parts
----------------------------------------

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0))))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1)))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1


----------------------------------------

(143) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MINUS(s(s(y0)), s(s(y1))) -> c3(MINUS(s(y0), s(y1))) by 
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))

----------------------------------------

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0))))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1)))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1


----------------------------------------

(145) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MINUS(s(z0), s(s(y1))) -> c3(MINUS(z0, s(y1))) by 
   MINUS(s(s(y0)), s(s(s(y1)))) -> c3(MINUS(s(y0), s(s(y1))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c3(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))

----------------------------------------

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0))))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c8_1, c4_1, c3_1


----------------------------------------

(147) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LOG(s(s(z0)), s(s(0))) -> c8(DIV(z0, s(s(0)))) by 
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))

----------------------------------------

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1)))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c4_1, c3_1, c8_1


----------------------------------------

(149) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MINUS(z0, s(s(y1))) -> c4(MINUS(z0, s(y1))) by 
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))

----------------------------------------

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   DIV(s(z0), s(s(0))) -> c6(MINUS(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c4_1, c3_1, c8_1


----------------------------------------

(151) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c4_1, c3_1, c8_1, c6


----------------------------------------

(153) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1)))) by 
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(z0), s(s(s(y1)))) -> c6(MINUS(s(z0), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(s(s(y1))))) -> c6(MINUS(s(z0), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))

----------------------------------------

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c4_1, c3_1, c8_1, c6


----------------------------------------

(155) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace DIV(s(z0), s(s(x1))) -> c6(MINUS(s(z0), s(s(x1)))) by 
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(z0), s(s(s(y1)))) -> c6(MINUS(s(z0), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(s(s(y1))))) -> c6(MINUS(s(z0), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))

----------------------------------------

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c4_1, c3_1, c8_1, c6


----------------------------------------

(157) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(MINUS(s(z0), s(s(x1)))) by 
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))

----------------------------------------

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c4_1, c3_1, c8_1, c6


----------------------------------------

(159) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(MINUS(z0, s(s(x1)))) by 
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))

----------------------------------------

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c4_1, c3_1, c8_1, c6


----------------------------------------

(161) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MINUS(s(s(y0)), s(s(s(y1)))) -> c4(MINUS(s(s(y0)), s(s(y1)))) by 
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(z0)), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(z0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(z0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))

----------------------------------------

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c4_1, c3_1, c8_1, c6


----------------------------------------

(163) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MINUS(s(y0), s(s(s(y1)))) -> c4(MINUS(s(y0), s(s(y1)))) by 
   MINUS(s(z0), s(s(s(s(y1))))) -> c4(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))

----------------------------------------

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1, c6


----------------------------------------

(165) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace DIV(s(z0), s(0)) -> c6(DIV(z0, s(0))) by 
   DIV(s(s(y0)), s(0)) -> c6(DIV(s(y0), s(0)))

----------------------------------------

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   DIV(s(z0), s(0)) -> c6(DIV(z0, s(0)))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(y0)), s(0)) -> c6(DIV(s(y0), s(0)))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(y0)), s(0)) -> c6(DIV(s(y0), s(0)))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1, c6


----------------------------------------

(167) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace DIV(s(z0), s(0)) -> c6(DIV(z0, s(0))) by 
   DIV(s(s(y0)), s(0)) -> c6(DIV(s(y0), s(0)))
   DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0)))

----------------------------------------

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(y0)), s(0)) -> c6(DIV(s(y0), s(0)))
   DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0)))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(y0)), s(0)) -> c6(DIV(s(y0), s(0)))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1, c6


----------------------------------------

(169) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace DIV(s(s(y0)), s(0)) -> c6(DIV(s(y0), s(0))) by 
   DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0)))
   DIV(s(s(s(s(y0)))), s(0)) -> c6(DIV(s(s(s(y0))), s(0)))

----------------------------------------

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(y0)), s(0)) -> c6(DIV(s(y0), s(0)))
   DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0)))
   DIV(s(s(s(s(y0)))), s(0)) -> c6(DIV(s(s(s(y0))), s(0)))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0)))
   DIV(s(s(s(s(y0)))), s(0)) -> c6(DIV(s(s(s(y0))), s(0)))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1, c6


----------------------------------------

(171) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace DIV(s(s(y0)), s(0)) -> c6(DIV(s(y0), s(0))) by 
   DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0)))
   DIV(s(s(s(s(y0)))), s(0)) -> c6(DIV(s(s(s(y0))), s(0)))
   DIV(s(s(s(s(s(y0))))), s(0)) -> c6(DIV(s(s(s(s(y0)))), s(0)))

----------------------------------------

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0)))
   DIV(s(s(s(s(y0)))), s(0)) -> c6(DIV(s(s(s(y0))), s(0)))
   DIV(s(s(s(s(s(y0))))), s(0)) -> c6(DIV(s(s(s(s(y0)))), s(0)))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0)))
   DIV(s(s(s(s(y0)))), s(0)) -> c6(DIV(s(s(s(y0))), s(0)))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1, c6


----------------------------------------

(173) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0))) by 
   DIV(s(s(s(s(y0)))), s(0)) -> c6(DIV(s(s(s(y0))), s(0)))
   DIV(s(s(s(s(s(y0))))), s(0)) -> c6(DIV(s(s(s(s(y0)))), s(0)))
   DIV(s(s(s(s(s(s(y0)))))), s(0)) -> c6(DIV(s(s(s(s(s(y0))))), s(0)))

----------------------------------------

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   minus(s(z0), s(z1)) -> minus(z0, z1)
   minus(z0, s(z1)) -> p(minus(z0, z1))
   minus(z0, 0) -> z0
   p(0) -> 0
   p(s(z0)) -> z0
   div(0, s(z0)) -> 0
   div(s(z0), s(z1)) -> s(div(minus(s(z0), s(z1)), s(z1)))
Tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(0))) -> c8(DIV(s(s(y0)), s(s(0))))
   LOG(s(s(s(y0))), s(s(0))) -> c8(DIV(s(y0), s(s(0))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(s(y0))), s(0)) -> c6(DIV(s(s(y0)), s(0)))
   DIV(s(s(s(s(y0)))), s(0)) -> c6(DIV(s(s(s(y0))), s(0)))
   DIV(s(s(s(s(s(y0))))), s(0)) -> c6(DIV(s(s(s(s(y0)))), s(0)))
   DIV(s(s(s(s(s(s(y0)))))), s(0)) -> c6(DIV(s(s(s(s(s(y0))))), s(0)))
S tuples:
   DIV(s(s(z0)), s(s(z1))) -> c6(DIV(minus(z0, z1), s(s(z1))), MINUS(s(s(z0)), s(s(z1))))
   DIV(s(z0), s(s(z1))) -> c6(DIV(p(minus(z0, z1)), s(s(z1))), MINUS(s(z0), s(s(z1))))
   DIV(s(x0), s(s(z1))) -> c6(DIV(p(p(minus(s(x0), z1))), s(s(z1))), MINUS(s(x0), s(s(z1))))
   LOG(s(s(s(s(z0)))), s(s(s(s(z1))))) -> c8(LOG(div(minus(z0, z1), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(s(z0)), s(s(z1))), s(s(s(s(z1))))), MINUS(s(s(z0)), s(s(z1))))
   LOG(s(s(s(z0))), s(s(s(s(z1))))) -> c8(LOG(div(p(minus(z0, z1)), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(s(z0), s(s(z1))), s(s(s(s(z1))))), MINUS(s(z0), s(s(z1))))
   LOG(s(s(z0)), s(s(s(s(z1))))) -> c8(LOG(div(p(p(minus(z0, z1))), s(s(s(s(z1))))), s(s(s(s(z1))))), DIV(minus(z0, s(s(z1))), s(s(s(s(z1))))), MINUS(z0, s(s(z1))))
   DIV(s(z0), s(s(s(s(x1))))) -> c6(MINUS(s(z0), s(s(s(s(x1))))))
   DIV(s(z0), s(s(s(0)))) -> c6(MINUS(s(z0), s(s(s(0)))))
   DIV(s(z0), s(s(s(x1)))) -> c6(MINUS(s(z0), s(s(s(x1)))))
   LOG(s(s(s(z0))), s(s(0))) -> c8(LOG(s(div(minus(s(z0), s(s(0))), s(s(0)))), s(s(0))), DIV(s(z0), s(s(0))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c8(LOG(div(z0, s(s(s(0)))), s(s(s(0)))), DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(0)))) -> c8(LOG(div(p(z0), s(s(s(0)))), s(s(s(0)))), DIV(minus(z0, s(0)), s(s(s(0)))))
   MINUS(s(s(s(y0))), s(s(s(y1)))) -> c3(MINUS(s(s(y0)), s(s(y1))))
   MINUS(s(s(z0)), s(s(s(y1)))) -> c3(MINUS(s(z0), s(s(y1))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c3(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(s(z0)), s(s(s(s(y1))))) -> c3(MINUS(s(z0), s(s(s(y1)))))
   MINUS(s(z0), s(s(s(y1)))) -> c3(MINUS(z0, s(s(y1))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c3(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c3(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(z0, s(s(s(y1)))) -> c4(MINUS(z0, s(s(y1))))
   MINUS(s(s(y0)), s(s(s(s(y1))))) -> c4(MINUS(s(s(y0)), s(s(s(y1)))))
   MINUS(s(y0), s(s(s(s(y1))))) -> c4(MINUS(s(y0), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(y1))))) -> c4(MINUS(s(s(s(y0))), s(s(s(y1)))))
   MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(y0)), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(z0), s(s(0))) -> c6
   DIV(s(s(y0)), s(s(s(y1)))) -> c6(MINUS(s(s(y0)), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(y1)))) -> c6(MINUS(s(s(s(y0))), s(s(s(y1)))))
   DIV(s(s(s(y0))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   DIV(s(s(y0)), s(s(s(s(y1))))) -> c6(MINUS(s(s(y0)), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   DIV(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   DIV(s(s(y0)), s(s(s(s(s(y1)))))) -> c6(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   DIV(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   DIV(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c6(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(z0)), s(s(s(s(s(s(y1))))))) -> c4(MINUS(s(s(z0)), s(s(s(s(s(y1)))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   MINUS(s(z0), s(s(s(s(s(y1)))))) -> c4(MINUS(s(z0), s(s(s(s(y1))))))
   MINUS(s(s(y0)), s(s(s(s(s(s(s(y1)))))))) -> c4(MINUS(s(s(y0)), s(s(s(s(s(s(y1))))))))
   MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))))
   MINUS(s(s(s(y0))), s(s(s(s(s(s(s(s(y1))))))))) -> c4(MINUS(s(s(s(y0))), s(s(s(s(s(s(s(y1)))))))))
   DIV(s(s(s(s(y0)))), s(0)) -> c6(DIV(s(s(s(y0))), s(0)))
   DIV(s(s(s(s(s(y0))))), s(0)) -> c6(DIV(s(s(s(s(y0)))), s(0)))
   DIV(s(s(s(s(s(s(y0)))))), s(0)) -> c6(DIV(s(s(s(s(s(y0))))), s(0)))
K tuples:
   LOG(s(s(s(z0))), s(s(s(s(x1))))) -> c(DIV(minus(s(z0), s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(s(z0))), s(s(s(0)))) -> c(DIV(minus(s(z0), s(0)), s(s(s(0)))))
   LOG(s(s(z0)), s(s(s(s(x1))))) -> c1(DIV(minus(z0, s(s(x1))), s(s(s(s(x1))))))
   LOG(s(s(z0)), s(s(s(0)))) -> c1(DIV(minus(z0, s(0)), s(s(s(0)))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(z0))), s(s(s(s(s(y1)))))) -> c(MINUS(s(z0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(z0))), s(s(s(s(s(s(y1))))))) -> c(MINUS(s(z0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(y0)), s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(y0), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(y1)))))) -> c1(MINUS(s(s(s(y0))), s(s(s(y1)))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(y1))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(y1)))))))
   LOG(s(s(z0)), s(s(s(s(s(y1)))))) -> c1(MINUS(z0, s(s(s(y1)))))
   LOG(s(s(s(y0))), s(s(s(s(s(s(y1))))))) -> c1(MINUS(s(y0), s(s(s(s(y1))))))
   LOG(s(s(s(s(y0)))), s(s(s(s(s(s(s(y1)))))))) -> c1(MINUS(s(s(y0)), s(s(s(s(s(y1)))))))
   LOG(s(s(s(s(s(s(y0)))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(s(y0)))), s(s(s(s(s(s(y1))))))))
   LOG(s(s(s(s(s(y0))))), s(s(s(s(s(s(s(s(y1))))))))) -> c1(MINUS(s(s(s(y0))), s(s(s(s(s(s(y1))))))))
Defined Rule Symbols:   minus_2, p_1, div_2

Defined Pair Symbols:   DIV_2, LOG_2, MINUS_2

Compound Symbols:   c6_2, c8_3, c6_1, c_1, c8_2, c1_1, c3_1, c8_1, c4_1, c6


----------------------------------------

(175) RelTrsToWeightedTrsProof (UPPER BOUND(ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(176)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   p(0) -> 0 [1]
   p(s(x)) -> x [1]
   minus(x, 0) -> x [1]
   minus(s(x), s(y)) -> minus(x, y) [1]
   minus(x, s(y)) -> p(minus(x, y)) [1]
   div(0, s(y)) -> 0 [1]
   div(s(x), s(y)) -> s(div(minus(s(x), s(y)), s(y))) [1]
   log(s(0), s(s(y))) -> 0 [1]
   log(s(s(x)), s(s(y))) -> s(log(div(minus(x, y), s(s(y))), s(s(y)))) [1]

Rewrite Strategy: INNERMOST
----------------------------------------

(177) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(178)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   p(0) -> 0 [1]
   p(s(x)) -> x [1]
   minus(x, 0) -> x [1]
   minus(s(x), s(y)) -> minus(x, y) [1]
   minus(x, s(y)) -> p(minus(x, y)) [1]
   div(0, s(y)) -> 0 [1]
   div(s(x), s(y)) -> s(div(minus(s(x), s(y)), s(y))) [1]
   log(s(0), s(s(y))) -> 0 [1]
   log(s(s(x)), s(s(y))) -> s(log(div(minus(x, y), s(s(y))), s(s(y)))) [1]

The TRS has the following type information:
p :: 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
minus :: 0:s -> 0:s -> 0:s
div :: 0:s -> 0:s -> 0:s
log :: 0:s -> 0:s -> 0:s

Rewrite Strategy: INNERMOST
----------------------------------------

(179) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:

   log_2

(c) The following functions are completely defined:

   minus_2
   div_2
   p_1

Due to the following rules being added:

   div(v0, v1) -> 0 [0]

And the following fresh constants: none

----------------------------------------

(180)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   p(0) -> 0 [1]
   p(s(x)) -> x [1]
   minus(x, 0) -> x [1]
   minus(s(x), s(y)) -> minus(x, y) [1]
   minus(x, s(y)) -> p(minus(x, y)) [1]
   div(0, s(y)) -> 0 [1]
   div(s(x), s(y)) -> s(div(minus(s(x), s(y)), s(y))) [1]
   log(s(0), s(s(y))) -> 0 [1]
   log(s(s(x)), s(s(y))) -> s(log(div(minus(x, y), s(s(y))), s(s(y)))) [1]
   div(v0, v1) -> 0 [0]

The TRS has the following type information:
p :: 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
minus :: 0:s -> 0:s -> 0:s
div :: 0:s -> 0:s -> 0:s
log :: 0:s -> 0:s -> 0:s

Rewrite Strategy: INNERMOST
----------------------------------------

(181) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(182)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   p(0) -> 0 [1]
   p(s(x)) -> x [1]
   minus(x, 0) -> x [1]
   minus(s(x), s(y)) -> minus(x, y) [1]
   minus(x, s(0)) -> p(x) [2]
   minus(s(x'), s(s(y'))) -> p(minus(x', y')) [2]
   minus(x, s(s(y''))) -> p(p(minus(x, y''))) [2]
   div(0, s(y)) -> 0 [1]
   div(s(x), s(y)) -> s(div(minus(x, y), s(y))) [2]
   div(s(x), s(y)) -> s(div(p(minus(s(x), y)), s(y))) [2]
   log(s(0), s(s(y))) -> 0 [1]
   log(s(s(x)), s(s(0))) -> s(log(div(x, s(s(0))), s(s(0)))) [2]
   log(s(s(s(x''))), s(s(s(y1)))) -> s(log(div(minus(x'', y1), s(s(s(y1)))), s(s(s(y1))))) [2]
   log(s(s(x)), s(s(s(y2)))) -> s(log(div(p(minus(x, y2)), s(s(s(y2)))), s(s(s(y2))))) [2]
   div(v0, v1) -> 0 [0]

The TRS has the following type information:
p :: 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
minus :: 0:s -> 0:s -> 0:s
div :: 0:s -> 0:s -> 0:s
log :: 0:s -> 0:s -> 0:s

Rewrite Strategy: INNERMOST
----------------------------------------

(183) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0

----------------------------------------

(184)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' = 1 + y, y >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + x, y)), 1 + y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   div(z, z') -{ 2 }-> 1 + div(minus(x, y), 1 + y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   log(z, z') -{ 1 }-> 0 :|: z' = 1 + (1 + y), z = 1 + 0, y >= 0
   log(z, z') -{ 2 }-> 1 + log(div(x, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), x >= 0, z = 1 + (1 + x)
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(x, y2)), 1 + (1 + (1 + y2))), 1 + (1 + (1 + y2))) :|: x >= 0, z' = 1 + (1 + (1 + y2)), y2 >= 0, z = 1 + (1 + x)
   log(z, z') -{ 2 }-> 1 + log(div(minus(x'', y1), 1 + (1 + (1 + y1))), 1 + (1 + (1 + y1))) :|: y1 >= 0, z' = 1 + (1 + (1 + y1)), x'' >= 0, z = 1 + (1 + (1 + x''))
   minus(z, z') -{ 1 }-> x :|: x >= 0, z = x, z' = 0
   minus(z, z') -{ 2 }-> p(x) :|: x >= 0, z' = 1 + 0, z = x
   minus(z, z') -{ 2 }-> p(p(minus(x, y''))) :|: z' = 1 + (1 + y''), x >= 0, y'' >= 0, z = x
   minus(z, z') -{ 2 }-> p(minus(x', y')) :|: z = 1 + x', z' = 1 + (1 + y'), x' >= 0, y' >= 0
   minus(z, z') -{ 1 }-> minus(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   p(z) -{ 1 }-> x :|: x >= 0, z = 1 + x
   p(z) -{ 1 }-> 0 :|: z = 0


----------------------------------------

(185) InliningProof (UPPER BOUND(ID))
Inlined the following terminating rules on right-hand sides where appropriate:

   p(z) -{ 1 }-> x :|: x >= 0, z = 1 + x
   p(z) -{ 1 }-> 0 :|: z = 0

----------------------------------------

(186)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' = 1 + y, y >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + x, y)), 1 + y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   div(z, z') -{ 2 }-> 1 + div(minus(x, y), 1 + y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   log(z, z') -{ 1 }-> 0 :|: z' = 1 + (1 + y), z = 1 + 0, y >= 0
   log(z, z') -{ 2 }-> 1 + log(div(x, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), x >= 0, z = 1 + (1 + x)
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(x, y2)), 1 + (1 + (1 + y2))), 1 + (1 + (1 + y2))) :|: x >= 0, z' = 1 + (1 + (1 + y2)), y2 >= 0, z = 1 + (1 + x)
   log(z, z') -{ 2 }-> 1 + log(div(minus(x'', y1), 1 + (1 + (1 + y1))), 1 + (1 + (1 + y1))) :|: y1 >= 0, z' = 1 + (1 + (1 + y1)), x'' >= 0, z = 1 + (1 + (1 + x''))
   minus(z, z') -{ 1 }-> x :|: x >= 0, z = x, z' = 0
   minus(z, z') -{ 3 }-> x' :|: x >= 0, z' = 1 + 0, z = x, x' >= 0, x = 1 + x'
   minus(z, z') -{ 2 }-> p(p(minus(x, y''))) :|: z' = 1 + (1 + y''), x >= 0, y'' >= 0, z = x
   minus(z, z') -{ 2 }-> p(minus(x', y')) :|: z = 1 + x', z' = 1 + (1 + y'), x' >= 0, y' >= 0
   minus(z, z') -{ 1 }-> minus(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   minus(z, z') -{ 3 }-> 0 :|: x >= 0, z' = 1 + 0, z = x, x = 0
   p(z) -{ 1 }-> x :|: x >= 0, z = 1 + x
   p(z) -{ 1 }-> 0 :|: z = 0


----------------------------------------

(187) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(188)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 2 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 2 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> minus(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0


----------------------------------------

(189) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID))
Found the following analysis order by SCC decomposition:

   { p }
   { minus }
   { div }
   { log }

----------------------------------------

(190)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 2 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 2 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> minus(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {p}, {minus}, {div}, {log}

----------------------------------------

(191) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(192)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 2 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 2 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> minus(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {p}, {minus}, {div}, {log}

----------------------------------------

(193) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: p
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z

----------------------------------------

(194)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 2 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 2 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> minus(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {p}, {minus}, {div}, {log}
Previous analysis results are:
  p: runtime: ?, size: O(n^1) [z]

----------------------------------------

(195) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: p
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 1

----------------------------------------

(196)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 2 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 2 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> minus(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {minus}, {div}, {log}
Previous analysis results are:
  p: runtime: O(1) [1], size: O(n^1) [z]

----------------------------------------

(197) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(198)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 2 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 2 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> minus(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {minus}, {div}, {log}
Previous analysis results are:
  p: runtime: O(1) [1], size: O(n^1) [z]

----------------------------------------

(199) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: minus
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z

----------------------------------------

(200)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 2 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 2 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> minus(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {minus}, {div}, {log}
Previous analysis results are:
  p: runtime: O(1) [1], size: O(n^1) [z]
  minus: runtime: ?, size: O(n^1) [z]

----------------------------------------

(201) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: minus
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 7 + 8*z'

----------------------------------------

(202)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 2 }-> 1 + div(p(minus(1 + (z - 1), z' - 1)), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 }-> 1 + div(minus(z - 1, z' - 1), 1 + (z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(p(minus(z - 2, z' - 3)), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(minus(z - 3, z' - 3), 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 2 }-> p(p(minus(z, z' - 2))) :|: z >= 0, z' - 2 >= 0
   minus(z, z') -{ 2 }-> p(minus(z - 1, z' - 2)) :|: z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> minus(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {div}, {log}
Previous analysis results are:
  p: runtime: O(1) [1], size: O(n^1) [z]
  minus: runtime: O(n^1) [7 + 8*z'], size: O(n^1) [z]

----------------------------------------

(203) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(204)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 1 + 8*z' }-> 1 + div(s', 1 + (z' - 1)) :|: s' >= 0, s' <= z - 1, z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 + 8*z' }-> 1 + div(s7, 1 + (z' - 1)) :|: s6 >= 0, s6 <= 1 + (z - 1), s7 >= 0, s7 <= s6, z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ -15 + 8*z' }-> 1 + log(div(s'', 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: s'' >= 0, s'' <= z - 3, z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ -14 + 8*z' }-> 1 + log(div(s9, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: s8 >= 0, s8 <= z - 2, s9 >= 0, s9 <= s8, z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 8*z' }-> s :|: s >= 0, s <= z - 1, z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ -6 + 8*z' }-> s2 :|: s1 >= 0, s1 <= z - 1, s2 >= 0, s2 <= s1, z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ -5 + 8*z' }-> s5 :|: s3 >= 0, s3 <= z, s4 >= 0, s4 <= s3, s5 >= 0, s5 <= s4, z >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {div}, {log}
Previous analysis results are:
  p: runtime: O(1) [1], size: O(n^1) [z]
  minus: runtime: O(n^1) [7 + 8*z'], size: O(n^1) [z]

----------------------------------------

(205) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: div
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

----------------------------------------

(206)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 1 + 8*z' }-> 1 + div(s', 1 + (z' - 1)) :|: s' >= 0, s' <= z - 1, z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 + 8*z' }-> 1 + div(s7, 1 + (z' - 1)) :|: s6 >= 0, s6 <= 1 + (z - 1), s7 >= 0, s7 <= s6, z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ -15 + 8*z' }-> 1 + log(div(s'', 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: s'' >= 0, s'' <= z - 3, z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ -14 + 8*z' }-> 1 + log(div(s9, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: s8 >= 0, s8 <= z - 2, s9 >= 0, s9 <= s8, z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 8*z' }-> s :|: s >= 0, s <= z - 1, z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ -6 + 8*z' }-> s2 :|: s1 >= 0, s1 <= z - 1, s2 >= 0, s2 <= s1, z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ -5 + 8*z' }-> s5 :|: s3 >= 0, s3 <= z, s4 >= 0, s4 <= s3, s5 >= 0, s5 <= s4, z >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {div}, {log}
Previous analysis results are:
  p: runtime: O(1) [1], size: O(n^1) [z]
  minus: runtime: O(n^1) [7 + 8*z'], size: O(n^1) [z]
  div: runtime: ?, size: INF

----------------------------------------

(207) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: div
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

----------------------------------------

(208)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   div(z, z') -{ 1 + 8*z' }-> 1 + div(s', 1 + (z' - 1)) :|: s' >= 0, s' <= z - 1, z - 1 >= 0, z' - 1 >= 0
   div(z, z') -{ 2 + 8*z' }-> 1 + div(s7, 1 + (z' - 1)) :|: s6 >= 0, s6 <= 1 + (z - 1), s7 >= 0, s7 <= s6, z - 1 >= 0, z' - 1 >= 0
   log(z, z') -{ 1 }-> 0 :|: z = 1 + 0, z' - 2 >= 0
   log(z, z') -{ -15 + 8*z' }-> 1 + log(div(s'', 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: s'' >= 0, s'' <= z - 3, z' - 3 >= 0, z - 3 >= 0
   log(z, z') -{ -14 + 8*z' }-> 1 + log(div(s9, 1 + (1 + (1 + (z' - 3)))), 1 + (1 + (1 + (z' - 3)))) :|: s8 >= 0, s8 <= z - 2, s9 >= 0, s9 <= s8, z - 2 >= 0, z' - 3 >= 0
   log(z, z') -{ 2 }-> 1 + log(div(z - 2, 1 + (1 + 0)), 1 + (1 + 0)) :|: z' = 1 + (1 + 0), z - 2 >= 0
   minus(z, z') -{ 8*z' }-> s :|: s >= 0, s <= z - 1, z - 1 >= 0, z' - 1 >= 0
   minus(z, z') -{ -6 + 8*z' }-> s2 :|: s1 >= 0, s1 <= z - 1, s2 >= 0, s2 <= s1, z - 1 >= 0, z' - 2 >= 0
   minus(z, z') -{ -5 + 8*z' }-> s5 :|: s3 >= 0, s3 <= z, s4 >= 0, s4 <= s3, s5 >= 0, s5 <= s4, z >= 0, z' - 2 >= 0
   minus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   minus(z, z') -{ 3 }-> 0 :|: z >= 0, z' = 1 + 0, z = 0
   minus(z, z') -{ 3 }-> z - 1 :|: z >= 0, z' = 1 + 0, z - 1 >= 0
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 1 }-> z - 1 :|: z - 1 >= 0

Function symbols to be analyzed: {div}, {log}
Previous analysis results are:
  p: runtime: O(1) [1], size: O(n^1) [z]
  minus: runtime: O(n^1) [7 + 8*z'], size: O(n^1) [z]
  div: runtime: INF, size: INF

----------------------------------------

(209) CompletionProof (UPPER BOUND(ID))
The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added:

   div(v0, v1) -> null_div [0]
   log(v0, v1) -> null_log [0]
   p(v0) -> null_p [0]
   minus(v0, v1) -> null_minus [0]

And the following fresh constants:    null_div, null_log, null_p, null_minus

----------------------------------------

(210)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   p(0) -> 0 [1]
   p(s(x)) -> x [1]
   minus(x, 0) -> x [1]
   minus(s(x), s(y)) -> minus(x, y) [1]
   minus(x, s(y)) -> p(minus(x, y)) [1]
   div(0, s(y)) -> 0 [1]
   div(s(x), s(y)) -> s(div(minus(s(x), s(y)), s(y))) [1]
   log(s(0), s(s(y))) -> 0 [1]
   log(s(s(x)), s(s(y))) -> s(log(div(minus(x, y), s(s(y))), s(s(y)))) [1]
   div(v0, v1) -> null_div [0]
   log(v0, v1) -> null_log [0]
   p(v0) -> null_p [0]
   minus(v0, v1) -> null_minus [0]

The TRS has the following type information:
p :: 0:s:null_div:null_log:null_p:null_minus -> 0:s:null_div:null_log:null_p:null_minus
0 :: 0:s:null_div:null_log:null_p:null_minus
s :: 0:s:null_div:null_log:null_p:null_minus -> 0:s:null_div:null_log:null_p:null_minus
minus :: 0:s:null_div:null_log:null_p:null_minus -> 0:s:null_div:null_log:null_p:null_minus -> 0:s:null_div:null_log:null_p:null_minus
div :: 0:s:null_div:null_log:null_p:null_minus -> 0:s:null_div:null_log:null_p:null_minus -> 0:s:null_div:null_log:null_p:null_minus
log :: 0:s:null_div:null_log:null_p:null_minus -> 0:s:null_div:null_log:null_p:null_minus -> 0:s:null_div:null_log:null_p:null_minus
null_div :: 0:s:null_div:null_log:null_p:null_minus
null_log :: 0:s:null_div:null_log:null_p:null_minus
null_p :: 0:s:null_div:null_log:null_p:null_minus
null_minus :: 0:s:null_div:null_log:null_p:null_minus

Rewrite Strategy: INNERMOST
----------------------------------------

(211) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   null_div => 0
   null_log => 0
   null_p => 0
   null_minus => 0

----------------------------------------

(212)
Obligation:
Complexity RNTS consisting of the following rules:

   div(z, z') -{ 1 }-> 0 :|: z' = 1 + y, y >= 0, z = 0
   div(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   div(z, z') -{ 1 }-> 1 + div(minus(1 + x, 1 + y), 1 + y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   log(z, z') -{ 1 }-> 0 :|: z' = 1 + (1 + y), z = 1 + 0, y >= 0
   log(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   log(z, z') -{ 1 }-> 1 + log(div(minus(x, y), 1 + (1 + y)), 1 + (1 + y)) :|: z' = 1 + (1 + y), x >= 0, y >= 0, z = 1 + (1 + x)
   minus(z, z') -{ 1 }-> x :|: x >= 0, z = x, z' = 0
   minus(z, z') -{ 1 }-> p(minus(x, y)) :|: z' = 1 + y, x >= 0, y >= 0, z = x
   minus(z, z') -{ 1 }-> minus(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   minus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   p(z) -{ 1 }-> x :|: x >= 0, z = 1 + x
   p(z) -{ 1 }-> 0 :|: z = 0
   p(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0

Only complete derivations are relevant for the runtime complexity.