KILLED
proof of input_sNn5jQ81Et.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) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(6) CpxWeightedTrs
    (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxTypedWeightedTrs
    (9) CompletionProof [UPPER BOUND(ID), 0 ms]
    (10) CpxTypedWeightedCompleteTrs
        (11) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (12) CpxRNTS
    (13) CompletionProof [UPPER BOUND(ID), 0 ms]
    (14) CpxTypedWeightedCompleteTrs
        (15) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (16) CpxTypedWeightedCompleteTrs
        (17) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (18) CpxRNTS
        (19) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (20) CpxRNTS
        (21) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
        (22) CpxRNTS
        (23) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (24) CpxRNTS
        (25) IntTrsBoundProof [UPPER BOUND(ID), 258 ms]
        (26) CpxRNTS
        (27) IntTrsBoundProof [UPPER BOUND(ID), 42 ms]
        (28) CpxRNTS
        (29) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (30) CpxRNTS
        (31) IntTrsBoundProof [UPPER BOUND(ID), 1515 ms]
        (32) CpxRNTS
        (33) IntTrsBoundProof [UPPER BOUND(ID), 148 ms]
        (34) CpxRNTS
        (35) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (36) CpxRNTS
        (37) IntTrsBoundProof [UPPER BOUND(ID), 255 ms]
        (38) CpxRNTS
        (39) IntTrsBoundProof [UPPER BOUND(ID), 116 ms]
        (40) CpxRNTS
        (41) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (42) CpxRNTS
        (43) IntTrsBoundProof [UPPER BOUND(ID), 3391 ms]
        (44) CpxRNTS
        (45) IntTrsBoundProof [UPPER BOUND(ID), 831 ms]
        (46) CpxRNTS
(47) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(48) CdtProblem
    (49) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (50) CdtProblem
    (51) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (52) CdtProblem
    (53) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (54) CdtProblem
    (55) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 167 ms]
    (56) CdtProblem
    (57) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (58) CdtProblem
    (59) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (60) CdtProblem
    (61) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 62 ms]
    (62) CdtProblem
    (63) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 125 ms]
    (64) CdtProblem
    (65) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (66) CdtProblem
    (67) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (68) CdtProblem
    (69) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 3 ms]
    (70) CdtProblem
    (71) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (72) CdtProblem
    (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (74) CdtProblem
    (75) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) CdtProblem
    (77) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (78) CdtProblem
    (79) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (80) CdtProblem
    (81) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 3 ms]
    (84) CdtProblem
    (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (88) CdtProblem
    (89) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (90) CdtProblem
    (91) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 44 ms]
    (92) CdtProblem
    (93) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (94) CdtProblem
    (95) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (102) CdtProblem
    (103) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (104) CdtProblem
    (105) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (108) CdtProblem
    (109) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
    (111) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (112) CdtProblem
    (113) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (114) CdtProblem
    (115) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (116) CdtProblem
    (117) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CdtProblem
    (119) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (120) CdtProblem
    (121) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (122) CdtProblem
    (123) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (124) CdtProblem
    (125) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (126) CdtProblem
    (127) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (128) CdtProblem
    (129) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 55 ms]
    (132) CdtProblem
    (133) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (134) CdtProblem
    (135) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (136) CdtProblem
    (137) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (138) CdtProblem
    (139) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (140) CdtProblem
    (141) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (142) CdtProblem
    (143) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (144) CdtProblem
    (145) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (146) CdtProblem
    (147) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (148) CdtProblem
    (149) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (150) CdtProblem
    (151) CdtLeafRemovalProof [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) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (158) CdtProblem
    (159) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (160) CdtProblem
    (161) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (162) CdtProblem
    (163) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (164) CdtProblem
    (165) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (166) CdtProblem
    (167) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (168) CdtProblem
    (169) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (170) CdtProblem
    (171) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (172) CdtProblem
    (173) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (174) CdtProblem
    (175) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (176) CdtProblem
    (177) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (178) CdtProblem
    (179) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (180) CdtProblem
    (181) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (182) CdtProblem
    (183) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (184) CdtProblem
    (185) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (186) CdtProblem
    (187) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (188) CdtProblem
    (189) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (190) CdtProblem
    (191) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (192) CdtProblem
    (193) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (194) CdtProblem
    (195) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (196) CdtProblem
    (197) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (198) CdtProblem
    (199) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (200) CdtProblem
    (201) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (202) CdtProblem
    (203) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (204) CdtProblem
    (205) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (206) CdtProblem
    (207) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (208) CdtProblem
    (209) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 36 ms]
    (210) CdtProblem
    (211) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (212) CdtProblem
    (213) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (214) CdtProblem
    (215) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (216) CdtProblem


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

(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:

   bsort(nil) -> nil
   bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
   bubble(nil) -> nil
   bubble(.(x, nil)) -> .(x, nil)
   bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
   last(nil) -> 0
   last(.(x, nil)) -> x
   last(.(x, .(y, z))) -> last(.(y, z))
   butlast(nil) -> nil
   butlast(.(x, nil)) -> nil
   butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

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:

   bsort(nil) -> nil
   bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
   bubble(nil) -> nil
   bubble(.(x, nil)) -> .(x, nil)
   bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
   last(nil) -> 0'
   last(.(x, nil)) -> x
   last(.(x, .(y, z))) -> last(.(y, z))
   butlast(nil) -> nil
   butlast(.(x, nil)) -> nil
   butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

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:

   bsort(nil) -> nil
   bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
   bubble(nil) -> nil
   bubble(.(x, nil)) -> .(x, nil)
   bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
   last(nil) -> 0
   last(.(x, nil)) -> x
   last(.(x, .(y, z))) -> last(.(y, z))
   butlast(nil) -> nil
   butlast(.(x, nil)) -> nil
   butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

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

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

(6)
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:

   bsort(nil) -> nil [1]
   bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y)))))) [1]
   bubble(nil) -> nil [1]
   bubble(.(x, nil)) -> .(x, nil) [1]
   bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z)))) [1]
   last(nil) -> 0 [1]
   last(.(x, nil)) -> x [1]
   last(.(x, .(y, z))) -> last(.(y, z)) [1]
   butlast(nil) -> nil [1]
   butlast(.(x, nil)) -> nil [1]
   butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z))) [1]

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

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

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

   bsort(nil) -> nil [1]
   bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y)))))) [1]
   bubble(nil) -> nil [1]
   bubble(.(x, nil)) -> .(x, nil) [1]
   bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z)))) [1]
   last(nil) -> 0 [1]
   last(.(x, nil)) -> x [1]
   last(.(x, .(y, z))) -> last(.(y, z)) [1]
   butlast(nil) -> nil [1]
   butlast(.(x, nil)) -> nil [1]
   butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z))) [1]

The TRS has the following type information:
bsort :: nil:.:if:0 -> nil:.:if:0
nil :: nil:.:if:0
. :: nil:.:if:0 -> nil:.:if:0 -> nil:.:if:0
last :: nil:.:if:0 -> nil:.:if:0
bubble :: nil:.:if:0 -> nil:.:if:0
butlast :: nil:.:if:0 -> nil:.:if:0
if :: <= -> nil:.:if:0 -> nil:.:if:0 -> nil:.:if:0
<= :: nil:.:if:0 -> nil:.:if:0 -> <=
0 :: nil:.:if:0

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

(9) 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:

   bsort(v0) -> null_bsort [0]
   bubble(v0) -> null_bubble [0]
   last(v0) -> null_last [0]
   butlast(v0) -> null_butlast [0]

And the following fresh constants:    null_bsort, null_bubble, null_last, null_butlast, const

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

(10)
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:

   bsort(nil) -> nil [1]
   bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y)))))) [1]
   bubble(nil) -> nil [1]
   bubble(.(x, nil)) -> .(x, nil) [1]
   bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z)))) [1]
   last(nil) -> 0 [1]
   last(.(x, nil)) -> x [1]
   last(.(x, .(y, z))) -> last(.(y, z)) [1]
   butlast(nil) -> nil [1]
   butlast(.(x, nil)) -> nil [1]
   butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z))) [1]
   bsort(v0) -> null_bsort [0]
   bubble(v0) -> null_bubble [0]
   last(v0) -> null_last [0]
   butlast(v0) -> null_butlast [0]

The TRS has the following type information:
bsort :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
nil :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
. :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
last :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
bubble :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
butlast :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
if :: <= -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
<= :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast -> <=
0 :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
null_bsort :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
null_bubble :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
null_last :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
null_butlast :: nil:.:if:0:null_bsort:null_bubble:null_last:null_butlast
const :: <=

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

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

   nil => 1
   0 => 0
   null_bsort => 0
   null_bubble => 0
   null_last => 0
   null_butlast => 0
   const => 0

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

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

   bsort(z') -{ 1 }-> last(1 + bubble(1 + x + y) + bsort(butlast(bubble(1 + x + y)))) :|: z' = 1 + x + y, x >= 0, y >= 0
   bsort(z') -{ 1 }-> 1 :|: z' = 1
   bsort(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   bubble(z') -{ 1 }-> 1 :|: z' = 1
   bubble(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   bubble(z') -{ 1 }-> 1 + x + 1 :|: x >= 0, z' = 1 + x + 1
   bubble(z') -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z' = 1 + x + (1 + y + z), z >= 0, x >= 0, y >= 0
   butlast(z') -{ 1 }-> 1 :|: z' = 1
   butlast(z') -{ 1 }-> 1 :|: x >= 0, z' = 1 + x + 1
   butlast(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   butlast(z') -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z' = 1 + x + (1 + y + z), z >= 0, x >= 0, y >= 0
   last(z') -{ 1 }-> x :|: x >= 0, z' = 1 + x + 1
   last(z') -{ 1 }-> last(1 + y + z) :|: z' = 1 + x + (1 + y + z), z >= 0, x >= 0, y >= 0
   last(z') -{ 1 }-> 0 :|: z' = 1
   last(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0

Only complete derivations are relevant for the runtime complexity.

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

(13) 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:
none

(c) The following functions are completely defined:

   bubble_1
   bsort_1
   butlast_1
   last_1

Due to the following rules being added:

   bubble(v0) -> null_bubble [0]
   bsort(v0) -> null_bsort [0]
   butlast(v0) -> null_butlast [0]
   last(v0) -> null_last [0]

And the following fresh constants:    null_bubble, null_bsort, null_butlast, null_last, const

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

(14)
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:

   bsort(nil) -> nil [1]
   bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y)))))) [1]
   bubble(nil) -> nil [1]
   bubble(.(x, nil)) -> .(x, nil) [1]
   bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z)))) [1]
   last(nil) -> 0 [1]
   last(.(x, nil)) -> x [1]
   last(.(x, .(y, z))) -> last(.(y, z)) [1]
   butlast(nil) -> nil [1]
   butlast(.(x, nil)) -> nil [1]
   butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z))) [1]
   bubble(v0) -> null_bubble [0]
   bsort(v0) -> null_bsort [0]
   butlast(v0) -> null_butlast [0]
   last(v0) -> null_last [0]

The TRS has the following type information:
bsort :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
nil :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
. :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
last :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
bubble :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
butlast :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
if :: <= -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
<= :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> <=
0 :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
null_bubble :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
null_bsort :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
null_butlast :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
null_last :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
const :: <=

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

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

(16)
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:

   bsort(nil) -> nil [1]
   bsort(.(x, nil)) -> last(.(.(x, nil), bsort(butlast(.(x, nil))))) [3]
   bsort(.(x, nil)) -> last(.(.(x, nil), bsort(butlast(null_bubble)))) [2]
   bsort(.(x, .(y', z'))) -> last(.(if(<=(x, y'), .(y', bubble(.(x, z'))), .(x, bubble(.(y', z')))), bsort(butlast(if(<=(x, y'), .(y', bubble(.(x, z'))), .(x, bubble(.(y', z')))))))) [3]
   bsort(.(x, .(y', z'))) -> last(.(if(<=(x, y'), .(y', bubble(.(x, z'))), .(x, bubble(.(y', z')))), bsort(butlast(null_bubble)))) [2]
   bsort(.(x, nil)) -> last(.(null_bubble, bsort(butlast(.(x, nil))))) [2]
   bsort(.(x, .(y'', z''))) -> last(.(null_bubble, bsort(butlast(if(<=(x, y''), .(y'', bubble(.(x, z''))), .(x, bubble(.(y'', z'')))))))) [2]
   bsort(.(x, y)) -> last(.(null_bubble, bsort(butlast(null_bubble)))) [1]
   bubble(nil) -> nil [1]
   bubble(.(x, nil)) -> .(x, nil) [1]
   bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z)))) [1]
   last(nil) -> 0 [1]
   last(.(x, nil)) -> x [1]
   last(.(x, .(y, z))) -> last(.(y, z)) [1]
   butlast(nil) -> nil [1]
   butlast(.(x, nil)) -> nil [1]
   butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z))) [1]
   bubble(v0) -> null_bubble [0]
   bsort(v0) -> null_bsort [0]
   butlast(v0) -> null_butlast [0]
   last(v0) -> null_last [0]

The TRS has the following type information:
bsort :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
nil :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
. :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
last :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
bubble :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
butlast :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
if :: <= -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
<= :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last -> <=
0 :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
null_bubble :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
null_bsort :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
null_butlast :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
null_last :: nil:.:if:0:null_bubble:null_bsort:null_butlast:null_last
const :: <=

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

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

   nil => 1
   0 => 0
   null_bubble => 0
   null_bsort => 0
   null_butlast => 0
   null_last => 0
   const => 0

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + x + 1))) :|: x >= 0, z1 = 1 + x + 1
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + bubble(1 + x + z'')) + (1 + x + bubble(1 + y'' + z''))))) :|: z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + x + 1) + bsort(butlast(0))) :|: x >= 0, z1 = 1 + x + 1
   bsort(z1) -{ 3 }-> last(1 + (1 + x + 1) + bsort(butlast(1 + x + 1))) :|: x >= 0, z1 = 1 + x + 1
   bsort(z1) -{ 2 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(0))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 3 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 = v0, v0 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 = v0, v0 >= 0
   bubble(z1) -{ 1 }-> 1 + x + 1 :|: x >= 0, z1 = 1 + x + 1
   bubble(z1) -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: x >= 0, z1 = 1 + x + 1
   butlast(z1) -{ 0 }-> 0 :|: z1 = v0, v0 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> x :|: x >= 0, z1 = 1 + x + 1
   last(z1) -{ 1 }-> last(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 = v0, v0 >= 0


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

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + bubble(1 + x + z'')) + (1 + x + bubble(1 + y'' + z''))))) :|: z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(0))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 3 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> last(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0


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

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

   { last }
   { bubble }
   { butlast }
   { bsort }

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + bubble(1 + x + z'')) + (1 + x + bubble(1 + y'' + z''))))) :|: z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(0))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 3 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> last(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {last}, {bubble}, {butlast}, {bsort}

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

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + bubble(1 + x + z'')) + (1 + x + bubble(1 + y'' + z''))))) :|: z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(0))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 3 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> last(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {last}, {bubble}, {butlast}, {bsort}

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

(25) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + bubble(1 + x + z'')) + (1 + x + bubble(1 + y'' + z''))))) :|: z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(0))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 3 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> last(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {last}, {bubble}, {butlast}, {bsort}
Previous analysis results are:
  last: runtime: ?, size: O(n^1) [z1]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: last
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 2 + z1

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + bubble(1 + x + z'')) + (1 + x + bubble(1 + y'' + z''))))) :|: z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(0))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 3 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> last(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {bubble}, {butlast}, {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]

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

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + bubble(1 + x + z'')) + (1 + x + bubble(1 + y'' + z''))))) :|: z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(0))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 3 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 4 + y + z }-> s :|: s >= 0, s <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {bubble}, {butlast}, {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: bubble
after applying outer abstraction to obtain an ITS,
resulting in: EXP with polynomial bound: ?

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + bubble(1 + x + z'')) + (1 + x + bubble(1 + y'' + z''))))) :|: z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(0))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 3 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 4 + y + z }-> s :|: s >= 0, s <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {bubble}, {butlast}, {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bubble: runtime: ?, size: EXP

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: bubble
after applying outer abstraction to obtain an ITS,
resulting in: EXP with polynomial bound: ?

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + bubble(1 + x + z'')) + (1 + x + bubble(1 + y'' + z''))))) :|: z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(0))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 3 }-> last(1 + (1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))) + bsort(butlast(1 + (1 + x + y') + (1 + y' + bubble(1 + x + z')) + (1 + x + bubble(1 + y' + z'))))) :|: x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 }-> 1 + (1 + x + y) + (1 + y + bubble(1 + x + z)) + (1 + x + bubble(1 + y + z)) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 4 + y + z }-> s :|: s >= 0, s <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {butlast}, {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bubble: runtime: EXP, size: EXP

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

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 + inf10 + inf12 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + s5) + (1 + x + s6)))) :|: s5 >= 0, s5 <= inf11, s6 >= 0, s6 <= inf13, z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 + inf + inf'' + inf2 + inf4 }-> last(1 + (1 + (1 + x + y') + (1 + y' + s') + (1 + x + s'')) + bsort(butlast(1 + (1 + x + y') + (1 + y' + s1) + (1 + x + s2)))) :|: s' >= 0, s' <= inf', s'' >= 0, s'' <= inf1, s1 >= 0, s1 <= inf3, s2 >= 0, s2 <= inf5, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 2 + inf6 + inf8 }-> last(1 + (1 + (1 + x + y') + (1 + y' + s3) + (1 + x + s4)) + bsort(butlast(0))) :|: s3 >= 0, s3 <= inf7, s4 >= 0, s4 <= inf9, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 + inf14 + inf16 }-> 1 + (1 + x + y) + (1 + y + s7) + (1 + x + s8) :|: s7 >= 0, s7 <= inf15, s8 >= 0, s8 <= inf17, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 4 + y + z }-> s :|: s >= 0, s <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {butlast}, {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bubble: runtime: EXP, size: EXP

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 + inf10 + inf12 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + s5) + (1 + x + s6)))) :|: s5 >= 0, s5 <= inf11, s6 >= 0, s6 <= inf13, z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 + inf + inf'' + inf2 + inf4 }-> last(1 + (1 + (1 + x + y') + (1 + y' + s') + (1 + x + s'')) + bsort(butlast(1 + (1 + x + y') + (1 + y' + s1) + (1 + x + s2)))) :|: s' >= 0, s' <= inf', s'' >= 0, s'' <= inf1, s1 >= 0, s1 <= inf3, s2 >= 0, s2 <= inf5, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 2 + inf6 + inf8 }-> last(1 + (1 + (1 + x + y') + (1 + y' + s3) + (1 + x + s4)) + bsort(butlast(0))) :|: s3 >= 0, s3 <= inf7, s4 >= 0, s4 <= inf9, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 + inf14 + inf16 }-> 1 + (1 + x + y) + (1 + y + s7) + (1 + x + s8) :|: s7 >= 0, s7 <= inf15, s8 >= 0, s8 <= inf17, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 4 + y + z }-> s :|: s >= 0, s <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {butlast}, {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bubble: runtime: EXP, size: EXP
  butlast: runtime: ?, size: O(n^1) [z1]

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: butlast
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 2 + z1

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

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

   bsort(z1) -{ 1 }-> last(1 + 0 + bsort(butlast(0))) :|: x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 2 }-> last(1 + 0 + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 2 + inf10 + inf12 }-> last(1 + 0 + bsort(butlast(1 + (1 + x + y'') + (1 + y'' + s5) + (1 + x + s6)))) :|: s5 >= 0, s5 <= inf11, s6 >= 0, s6 <= inf13, z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 2 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(0))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(butlast(1 + (z1 - 2) + 1))) :|: z1 - 2 >= 0
   bsort(z1) -{ 3 + inf + inf'' + inf2 + inf4 }-> last(1 + (1 + (1 + x + y') + (1 + y' + s') + (1 + x + s'')) + bsort(butlast(1 + (1 + x + y') + (1 + y' + s1) + (1 + x + s2)))) :|: s' >= 0, s' <= inf', s'' >= 0, s'' <= inf1, s1 >= 0, s1 <= inf3, s2 >= 0, s2 <= inf5, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 2 + inf6 + inf8 }-> last(1 + (1 + (1 + x + y') + (1 + y' + s3) + (1 + x + s4)) + bsort(butlast(0))) :|: s3 >= 0, s3 <= inf7, s4 >= 0, s4 <= inf9, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 + inf14 + inf16 }-> 1 + (1 + x + y) + (1 + y + s7) + (1 + x + s8) :|: s7 >= 0, s7 <= inf15, s8 >= 0, s8 <= inf17, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 1 }-> 1 + x + butlast(1 + y + z) :|: z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 4 + y + z }-> s :|: s >= 0, s <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bubble: runtime: EXP, size: EXP
  butlast: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]

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

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

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

   bsort(z1) -{ 4 + z1 }-> last(1 + 0 + bsort(s13)) :|: s13 >= 0, s13 <= 1 + (z1 - 2) + 1, z1 - 2 >= 0
   bsort(z1) -{ 8 + inf10 + inf12 + s5 + s6 + 2*x + 2*y'' }-> last(1 + 0 + bsort(s14)) :|: s14 >= 0, s14 <= 1 + (1 + x + y'') + (1 + y'' + s5) + (1 + x + s6), s5 >= 0, s5 <= inf11, s6 >= 0, s6 <= inf13, z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 3 }-> last(1 + 0 + bsort(s15)) :|: s15 >= 0, s15 <= 0, x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 4 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(s10)) :|: s10 >= 0, s10 <= 0, z1 - 2 >= 0
   bsort(z1) -{ 5 + z1 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(s9)) :|: s9 >= 0, s9 <= 1 + (z1 - 2) + 1, z1 - 2 >= 0
   bsort(z1) -{ 9 + inf + inf'' + inf2 + inf4 + s1 + s2 + 2*x + 2*y' }-> last(1 + (1 + (1 + x + y') + (1 + y' + s') + (1 + x + s'')) + bsort(s11)) :|: s11 >= 0, s11 <= 1 + (1 + x + y') + (1 + y' + s1) + (1 + x + s2), s' >= 0, s' <= inf', s'' >= 0, s'' <= inf1, s1 >= 0, s1 <= inf3, s2 >= 0, s2 <= inf5, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 4 + inf6 + inf8 }-> last(1 + (1 + (1 + x + y') + (1 + y' + s3) + (1 + x + s4)) + bsort(s12)) :|: s12 >= 0, s12 <= 0, s3 >= 0, s3 <= inf7, s4 >= 0, s4 <= inf9, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 + inf14 + inf16 }-> 1 + (1 + x + y) + (1 + y + s7) + (1 + x + s8) :|: s7 >= 0, s7 <= inf15, s8 >= 0, s8 <= inf17, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 4 + y + z }-> 1 + x + s16 :|: s16 >= 0, s16 <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 4 + y + z }-> s :|: s >= 0, s <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bubble: runtime: EXP, size: EXP
  butlast: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   bsort(z1) -{ 4 + z1 }-> last(1 + 0 + bsort(s13)) :|: s13 >= 0, s13 <= 1 + (z1 - 2) + 1, z1 - 2 >= 0
   bsort(z1) -{ 8 + inf10 + inf12 + s5 + s6 + 2*x + 2*y'' }-> last(1 + 0 + bsort(s14)) :|: s14 >= 0, s14 <= 1 + (1 + x + y'') + (1 + y'' + s5) + (1 + x + s6), s5 >= 0, s5 <= inf11, s6 >= 0, s6 <= inf13, z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 3 }-> last(1 + 0 + bsort(s15)) :|: s15 >= 0, s15 <= 0, x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 4 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(s10)) :|: s10 >= 0, s10 <= 0, z1 - 2 >= 0
   bsort(z1) -{ 5 + z1 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(s9)) :|: s9 >= 0, s9 <= 1 + (z1 - 2) + 1, z1 - 2 >= 0
   bsort(z1) -{ 9 + inf + inf'' + inf2 + inf4 + s1 + s2 + 2*x + 2*y' }-> last(1 + (1 + (1 + x + y') + (1 + y' + s') + (1 + x + s'')) + bsort(s11)) :|: s11 >= 0, s11 <= 1 + (1 + x + y') + (1 + y' + s1) + (1 + x + s2), s' >= 0, s' <= inf', s'' >= 0, s'' <= inf1, s1 >= 0, s1 <= inf3, s2 >= 0, s2 <= inf5, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 4 + inf6 + inf8 }-> last(1 + (1 + (1 + x + y') + (1 + y' + s3) + (1 + x + s4)) + bsort(s12)) :|: s12 >= 0, s12 <= 0, s3 >= 0, s3 <= inf7, s4 >= 0, s4 <= inf9, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 + inf14 + inf16 }-> 1 + (1 + x + y) + (1 + y + s7) + (1 + x + s8) :|: s7 >= 0, s7 <= inf15, s8 >= 0, s8 <= inf17, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 4 + y + z }-> 1 + x + s16 :|: s16 >= 0, s16 <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 4 + y + z }-> s :|: s >= 0, s <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bubble: runtime: EXP, size: EXP
  butlast: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bsort: runtime: ?, size: INF

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   bsort(z1) -{ 4 + z1 }-> last(1 + 0 + bsort(s13)) :|: s13 >= 0, s13 <= 1 + (z1 - 2) + 1, z1 - 2 >= 0
   bsort(z1) -{ 8 + inf10 + inf12 + s5 + s6 + 2*x + 2*y'' }-> last(1 + 0 + bsort(s14)) :|: s14 >= 0, s14 <= 1 + (1 + x + y'') + (1 + y'' + s5) + (1 + x + s6), s5 >= 0, s5 <= inf11, s6 >= 0, s6 <= inf13, z'' >= 0, x >= 0, y'' >= 0, z1 = 1 + x + (1 + y'' + z'')
   bsort(z1) -{ 3 }-> last(1 + 0 + bsort(s15)) :|: s15 >= 0, s15 <= 0, x >= 0, y >= 0, z1 = 1 + x + y
   bsort(z1) -{ 4 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(s10)) :|: s10 >= 0, s10 <= 0, z1 - 2 >= 0
   bsort(z1) -{ 5 + z1 }-> last(1 + (1 + (z1 - 2) + 1) + bsort(s9)) :|: s9 >= 0, s9 <= 1 + (z1 - 2) + 1, z1 - 2 >= 0
   bsort(z1) -{ 9 + inf + inf'' + inf2 + inf4 + s1 + s2 + 2*x + 2*y' }-> last(1 + (1 + (1 + x + y') + (1 + y' + s') + (1 + x + s'')) + bsort(s11)) :|: s11 >= 0, s11 <= 1 + (1 + x + y') + (1 + y' + s1) + (1 + x + s2), s' >= 0, s' <= inf', s'' >= 0, s'' <= inf1, s1 >= 0, s1 <= inf3, s2 >= 0, s2 <= inf5, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 4 + inf6 + inf8 }-> last(1 + (1 + (1 + x + y') + (1 + y' + s3) + (1 + x + s4)) + bsort(s12)) :|: s12 >= 0, s12 <= 0, s3 >= 0, s3 <= inf7, s4 >= 0, s4 <= inf9, x >= 0, z' >= 0, y' >= 0, z1 = 1 + x + (1 + y' + z')
   bsort(z1) -{ 1 }-> 1 :|: z1 = 1
   bsort(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 :|: z1 = 1
   bubble(z1) -{ 0 }-> 0 :|: z1 >= 0
   bubble(z1) -{ 1 }-> 1 + (z1 - 2) + 1 :|: z1 - 2 >= 0
   bubble(z1) -{ 1 + inf14 + inf16 }-> 1 + (1 + x + y) + (1 + y + s7) + (1 + x + s8) :|: s7 >= 0, s7 <= inf15, s8 >= 0, s8 <= inf17, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   butlast(z1) -{ 1 }-> 1 :|: z1 = 1
   butlast(z1) -{ 1 }-> 1 :|: z1 - 2 >= 0
   butlast(z1) -{ 0 }-> 0 :|: z1 >= 0
   butlast(z1) -{ 4 + y + z }-> 1 + x + s16 :|: s16 >= 0, s16 <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 4 + y + z }-> s :|: s >= 0, s <= 1 + y + z, z >= 0, z1 = 1 + x + (1 + y + z), x >= 0, y >= 0
   last(z1) -{ 1 }-> 0 :|: z1 = 1
   last(z1) -{ 0 }-> 0 :|: z1 >= 0
   last(z1) -{ 1 }-> z1 - 2 :|: z1 - 2 >= 0

Function symbols to be analyzed: {bsort}
Previous analysis results are:
  last: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bubble: runtime: EXP, size: EXP
  butlast: runtime: O(n^1) [2 + z1], size: O(n^1) [z1]
  bsort: runtime: INF, size: INF

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

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

(48)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   bubble(nil) -> nil
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   last(nil) -> 0
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
Tuples:
   BSORT(nil) -> c
   BSORT(.(z0, z1)) -> c1(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BUBBLE(.(z0, z1)))
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(nil) -> c3
   BUBBLE(.(z0, nil)) -> c4
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(nil) -> c7
   LAST(.(z0, nil)) -> c8
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(nil) -> c10
   BUTLAST(.(z0, nil)) -> c11
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
S tuples:
   BSORT(nil) -> c
   BSORT(.(z0, z1)) -> c1(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BUBBLE(.(z0, z1)))
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(nil) -> c3
   BUBBLE(.(z0, nil)) -> c4
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(nil) -> c7
   LAST(.(z0, nil)) -> c8
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(nil) -> c10
   BUTLAST(.(z0, nil)) -> c11
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
K tuples:none
Defined Rule Symbols:   bsort_1, bubble_1, last_1, butlast_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c, c1_2, c2_4, c3, c4, c5_1, c6_1, c7, c8, c9_1, c10, c11, c12_1


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

(49) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 7 trailing nodes:
   BUTLAST(nil) -> c10
   BUTLAST(.(z0, nil)) -> c11
   LAST(nil) -> c7
   LAST(.(z0, nil)) -> c8
   BUBBLE(.(z0, nil)) -> c4
   BSORT(nil) -> c
   BUBBLE(nil) -> c3

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

(50)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   bubble(nil) -> nil
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   last(nil) -> 0
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
Tuples:
   BSORT(.(z0, z1)) -> c1(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BUBBLE(.(z0, z1)))
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
S tuples:
   BSORT(.(z0, z1)) -> c1(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BUBBLE(.(z0, z1)))
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
K tuples:none
Defined Rule Symbols:   bsort_1, bubble_1, last_1, butlast_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c1_2, c2_4, c5_1, c6_1, c9_1, c12_1


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

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

(52)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   bubble(nil) -> nil
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   last(nil) -> 0
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
Tuples:
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
S tuples:
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
K tuples:none
Defined Rule Symbols:   bsort_1, bubble_1, last_1, butlast_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_4, c5_1, c6_1, c9_1, c12_1, c_1


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

(53) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   bubble(nil) -> nil
   last(nil) -> 0

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

(54)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
S tuples:
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
K tuples:none
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_4, c5_1, c6_1, c9_1, c12_1, c_1


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

(55) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
We considered the (Usable) Rules:none
And the Tuples:
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(.(x_1, x_2)) = 0
   POL(<=(x_1, x_2)) = [1] + x_1 + x_2
   POL(BSORT(x_1)) = [1]
   POL(BUBBLE(x_1)) = x_1
   POL(BUTLAST(x_1)) = 0
   POL(LAST(x_1)) = 0
   POL(bsort(x_1)) = [1]
   POL(bubble(x_1)) = 0
   POL(butlast(x_1)) = 0
   POL(c(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c2(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_3 + x_4
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(if(x_1, x_2, x_3)) = [1] + x_1
   POL(last(x_1)) = [1]
   POL(nil) = [1]

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

(56)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
S tuples:
   BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
K tuples:
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_4, c5_1, c6_1, c9_1, c12_1, c_1


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

(57) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, z1)) -> c2(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))), BSORT(butlast(bubble(.(z0, z1)))), BUTLAST(bubble(.(z0, z1))), BUBBLE(.(z0, z1))) by 
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))), BUBBLE(.(z0, nil)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(bubble(.(z0, .(z1, z2))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))), BUBBLE(.(z0, nil)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))

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

(58)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))), BUBBLE(.(z0, nil)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(bubble(.(z0, .(z1, z2))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))), BUBBLE(.(z0, nil)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
S tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))), BUBBLE(.(z0, nil)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(bubble(.(z0, .(z1, z2))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))), BUBBLE(.(z0, nil)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
K tuples:
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4


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

(59) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(60)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
S tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3


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

(61) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
We considered the (Usable) Rules:
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
And the Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(.(x_1, x_2)) = [1] + x_2
   POL(<=(x_1, x_2)) = [1] + x_1 + x_2
   POL(BSORT(x_1)) = [1] + x_1
   POL(BUBBLE(x_1)) = 0
   POL(BUTLAST(x_1)) = 0
   POL(LAST(x_1)) = 0
   POL(bsort(x_1)) = [1]
   POL(bubble(x_1)) = [1]
   POL(butlast(x_1)) = x_1
   POL(c(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c2(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c2(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_3 + x_4
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(if(x_1, x_2, x_3)) = 0
   POL(last(x_1)) = [1]
   POL(nil) = 0

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

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
S tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3


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

(63) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
We considered the (Usable) Rules:
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
And the Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(.(x_1, x_2)) = [2] + x_2
   POL(<=(x_1, x_2)) = [3] + x_1 + x_2
   POL(BSORT(x_1)) = [2]x_1
   POL(BUBBLE(x_1)) = x_1
   POL(BUTLAST(x_1)) = 0
   POL(LAST(x_1)) = 0
   POL(bsort(x_1)) = 0
   POL(bubble(x_1)) = [2]
   POL(butlast(x_1)) = x_1
   POL(c(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c2(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c2(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_3 + x_4
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(if(x_1, x_2, x_3)) = 0
   POL(last(x_1)) = [3]
   POL(nil) = 0

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

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3


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

(65) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))) by 
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(bubble(.(z0, .(z1, z2))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))

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

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(bubble(.(z0, .(z1, z2))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(LAST(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1)))))))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3


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

(67) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(bubble(.(z0, .(z1, z2))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))))

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

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3


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

(69) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2)))) by 
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4


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

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4


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

(73) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil)))) by 
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4


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

(75) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2)))) by 
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4


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

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c2(BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4, c2_2


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

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4, c1_1


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

(81) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil)))) by 
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4, c1_1


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

(83) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(butlast(.(z0, nil)))))) by 
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil)))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4, c1_1


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

(85) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(bubble(.(z0, nil))))))) by 
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4, c1_1


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

(87) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2)))))))) by 
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(bubble(.(z0, .(z1, z2))))))), BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c2_4, c1_1


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

(89) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, .(z1, z2))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))))))

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1


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

(91) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2)))) by 
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1


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

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

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c2(BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1, c2_2


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

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1, c3_1


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

(97) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(x0, .(z0, nil))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))), BSORT(butlast(bubble(.(x0, .(z0, nil))))), BUTLAST(bubble(.(x0, .(z0, nil)))), BUBBLE(.(x0, .(z0, nil)))) by BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
----------------------------------------

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1, c3_1


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

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2)))))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1, c3_1


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

(101) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(x0, .(z0, .(z1, z2)))) -> c2(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))), BSORT(butlast(bubble(.(x0, .(z0, .(z1, z2)))))), BUTLAST(bubble(.(x0, .(z0, .(z1, z2))))), BUBBLE(.(x0, .(z0, .(z1, z2))))) by BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
----------------------------------------

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1, c3_1


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

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1, c3_1


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

(105) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(x1, nil))) -> c2(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))), BSORT(butlast(bubble(.(z0, .(x1, nil))))), BUTLAST(bubble(.(z0, .(x1, nil)))), BUBBLE(.(z0, .(x1, nil)))) by BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
----------------------------------------

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1, c3_1


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

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

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_4, c2_3, c1_1, c3_1


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

(109) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(x1, .(z1, z2)))) -> c2(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))), BSORT(butlast(bubble(.(z0, .(x1, .(z1, z2)))))), BUTLAST(bubble(.(z0, .(x1, .(z1, z2))))), BUBBLE(.(z0, .(x1, .(z1, z2))))) by BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
----------------------------------------

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c1_1, c3_1, c2_4


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

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

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c1_1, c3_1


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

(113) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil)))) by BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(.(z0, nil)))
----------------------------------------

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(.(z0, nil)))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(.(z0, nil)))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c1_1, c3_1


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

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

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c1_1, c3_1, c2_2


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

(117) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil)))) by BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(.(z0, nil)))
----------------------------------------

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(.(z0, nil)))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(.(z0, nil)))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c1_1, c3_1, c2_2


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

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

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c1_1, c3_1, c2_2


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

(121) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(bubble(.(z0, .(z1, z2))))) by BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))))
----------------------------------------

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c2(BSORT(butlast(bubble(.(z0, .(z1, z2))))), BUTLAST(bubble(.(z0, .(z1, z2)))), BUBBLE(.(z0, .(z1, z2))))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c2_3, c1_1, c3_1, c2_2


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

(123) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, .(z1, z2))) -> c1(BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))))

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

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c5_1, c6_1, c9_1, c12_1, c_1, c1_1, c2_3, c3_1, c2_2


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

(125) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BUBBLE(.(z0, .(z1, z2))) -> c5(BUBBLE(.(z0, z2))) by 
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))

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

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c_1, c1_1, c2_3, c3_1, c2_2, c5_1


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

(127) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(bubble(.(z0, nil)))) by BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(.(z0, nil)))
----------------------------------------

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))), BUTLAST(.(z0, nil)))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1


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

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

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1


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

(131) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
We considered the (Usable) Rules:
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
And the Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(.(x_1, x_2)) = [1] + x_2
   POL(<=(x_1, x_2)) = 0
   POL(BSORT(x_1)) = 0
   POL(BUBBLE(x_1)) = 0
   POL(BUTLAST(x_1)) = x_1
   POL(LAST(x_1)) = 0
   POL(bsort(x_1)) = [1]
   POL(bubble(x_1)) = 0
   POL(butlast(x_1)) = 0
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c2(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(if(x_1, x_2, x_3)) = 0
   POL(last(x_1)) = [1]
   POL(nil) = 0

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

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1


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

(133) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), bsort(nil)))) by BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), nil)))
----------------------------------------

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), nil)))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1


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

(135) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, nil)) -> c(LAST(.(bubble(.(z0, nil)), nil)))

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

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1


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

(137) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil)))))) by BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
----------------------------------------

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1


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

(139) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil)))))) by BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
----------------------------------------

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1


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

(141) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BUBBLE(.(z0, .(z1, z2))) -> c6(BUBBLE(.(z1, z2))) by 
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))), BUBBLE(.(z0, .(z1, nil))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   LAST_1, BUTLAST_1, BSORT_1, BUBBLE_1

Compound Symbols:   c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1


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

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

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil))))))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   LAST_1, BUTLAST_1, BSORT_1, BUBBLE_1

Compound Symbols:   c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1


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

(145) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(x0, .(z0, nil))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, nil))), .(x0, .(z0, nil))), bsort(butlast(bubble(.(x0, .(z0, nil)))))))) by BSORT(.(z0, .(z1, nil))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))))
----------------------------------------

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   LAST_1, BUTLAST_1, BSORT_1, BUBBLE_1

Compound Symbols:   c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1


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

(147) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, .(z1, nil))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))))

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

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2)))))))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   LAST_1, BUTLAST_1, BSORT_1, BUBBLE_1

Compound Symbols:   c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1


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

(149) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(x0, .(z0, .(z1, z2)))) -> c(LAST(.(if(<=(x0, z0), .(z0, bubble(.(x0, .(z1, z2)))), .(x0, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2)))))), bsort(butlast(bubble(.(x0, .(z0, .(z1, z2))))))))) by BSORT(.(z0, .(z1, .(z2, z3)))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))))))
----------------------------------------

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   LAST_1, BUTLAST_1, BSORT_1, BUBBLE_1

Compound Symbols:   c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1


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

(151) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))))))

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
S tuples:
   LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2)))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   LAST_1, BUTLAST_1, BSORT_1, BUBBLE_1

Compound Symbols:   c9_1, c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1


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

(153) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LAST(.(z0, .(z1, z2))) -> c9(LAST(.(z1, z2))) by 
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))

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

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUTLAST_1, BSORT_1, BUBBLE_1, LAST_1

Compound Symbols:   c12_1, c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1


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

(155) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BUTLAST(.(z0, .(z1, z2))) -> c12(BUTLAST(.(z1, z2))) by 
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))

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

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil))))))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1


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

(157) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(x1, nil))) -> c(LAST(.(if(<=(z0, x1), .(x1, .(z0, nil)), .(z0, bubble(.(x1, nil)))), bsort(butlast(bubble(.(z0, .(x1, nil)))))))) by BSORT(.(z0, .(z1, nil))) -> c(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))))
----------------------------------------

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, nil))) -> c(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1


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

(159) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, .(z1, nil))) -> c(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))))

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

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2)))))))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1


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

(161) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(x1, .(z1, z2)))) -> c(LAST(.(if(<=(z0, x1), .(x1, if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))), .(z0, bubble(.(x1, .(z1, z2))))), bsort(butlast(bubble(.(z0, .(x1, .(z1, z2))))))))) by BSORT(.(z0, .(z1, .(z2, z3)))) -> c(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))))))
----------------------------------------

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1


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

(163) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))))))

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

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2)))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1


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

(165) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(bubble(.(z0, .(z1, z2))))) by BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))))
----------------------------------------

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1


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

(167) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, .(z1, z2))) -> c3(BUTLAST(if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))))

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

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1


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

(169) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3))))) by BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
----------------------------------------

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1


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

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

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1


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

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

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1)))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c1_1, c3_1, c2_3, c2_2, c5_1, c6_1, c9_1, c12_1, c4_1


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

(175) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BSORT(.(z0, z1)) -> c(BUBBLE(.(z0, z1))) by 
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))

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

(176)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c1_1, c3_1, c2_3, c2_2, c5_1, c_1, c6_1, c9_1, c12_1, c4_1


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

(177) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BSORT(.(z0, .(z1, z2))) -> c1(BUBBLE(.(z0, .(z1, z2)))) by 
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))

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

(178)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c3_1, c2_3, c2_2, c5_1, c_1, c6_1, c9_1, c12_1, c4_1, c1_1


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

(179) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BSORT(.(z0, .(z1, z2))) -> c3(BUBBLE(.(z0, .(z1, z2)))) by 
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))

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

(180)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_3, c2_2, c5_1, c_1, c6_1, c9_1, c12_1, c4_1, c1_1, c3_1


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

(181) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(bubble(.(z0, .(z1, .(z2, z3)))))), BUBBLE(.(z0, .(z1, .(z2, z3))))) by BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
----------------------------------------

(182)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, bubble(.(z1, .(z2, z3))))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_2, c5_1, c_1, c6_1, c9_1, c12_1, c4_1, c1_1, c3_1, c2_3


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

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

(184)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c2(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))), BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_2, c5_1, c_1, c6_1, c9_1, c12_1, c4_1, c1_1, c3_1


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

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

(186)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_2, c5_1, c_1, c6_1, c9_1, c12_1, c4_1, c1_1, c3_1, c7_1


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

(187) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(bubble(.(z0, nil))))) by BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
----------------------------------------

(188)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
S tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_2, c5_1, c_1, c6_1, c9_1, c12_1, c4_1, c1_1, c3_1, c7_1


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

(189) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil))))) by BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
----------------------------------------

(190)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_2, c5_1, c_1, c6_1, c9_1, c12_1, c4_1, c1_1, c3_1, c7_1


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

(191) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c5(BUBBLE(.(z0, .(y1, y2)))) by 
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))

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

(192)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil)))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c2_2, c_1, c6_1, c9_1, c12_1, c4_1, c1_1, c3_1, c7_1, c5_1


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

(193) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(bubble(.(z0, nil))))) by BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
----------------------------------------

(194)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c6_1, c2_2, c9_1, c12_1, c4_1, c1_1, c3_1, c7_1, c5_1


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

(195) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil)))) by BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), nil)))
----------------------------------------

(196)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), nil)))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c6_1, c2_2, c9_1, c12_1, c4_1, c1_1, c3_1, c7_1, c5_1


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

(197) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), nil)))

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

(198)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil))))
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BSORT_1, BUBBLE_1, LAST_1, BUTLAST_1

Compound Symbols:   c_1, c6_1, c2_2, c9_1, c12_1, c4_1, c1_1, c3_1, c7_1, c5_1


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

(199) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BSORT(.(z0, nil)) -> c(LAST(.(.(z0, nil), bsort(nil)))) by none

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

(200)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, BSORT_1, LAST_1, BUTLAST_1

Compound Symbols:   c6_1, c2_2, c9_1, c12_1, c4_1, c_1, c1_1, c3_1, c7_1, c5_1


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

(201) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil)))))) by BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))
----------------------------------------

(202)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, BSORT_1, LAST_1, BUTLAST_1

Compound Symbols:   c6_1, c2_2, c9_1, c12_1, c4_1, c_1, c1_1, c3_1, c7_1, c5_1


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

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

(204)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil))))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, BSORT_1, LAST_1, BUTLAST_1

Compound Symbols:   c6_1, c2_2, c9_1, c12_1, c4_1, c_1, c1_1, c3_1, c7_1, c5_1, c2_1


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

(205) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(bubble(.(z0, .(z1, nil)))))) by BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))
----------------------------------------

(206)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))), BSORT(butlast(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, bubble(.(z1, nil)))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c4_1, c_1, c1_1, c3_1, c7_1, c2_2, c5_1, c2_1


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

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

(208)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c4_1, c_1, c1_1, c3_1, c7_1, c2_2, c5_1, c2_1


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

(209) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
We considered the (Usable) Rules:
   butlast(.(z0, nil)) -> nil
And the Tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(.(x_1, x_2)) = [1]
   POL(<=(x_1, x_2)) = x_2
   POL(BSORT(x_1)) = x_1
   POL(BUBBLE(x_1)) = 0
   POL(BUTLAST(x_1)) = x_1
   POL(LAST(x_1)) = 0
   POL(bsort(x_1)) = [1]
   POL(bubble(x_1)) = 0
   POL(butlast(x_1)) = 0
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c2(x_1)) = x_1
   POL(c2(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(if(x_1, x_2, x_3)) = [1] + x_1
   POL(last(x_1)) = [1]
   POL(nil) = 0

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

(210)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2))))
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c4_1, c_1, c1_1, c3_1, c7_1, c2_2, c5_1, c2_1


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

(211) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BUBBLE(.(z0, .(z1, .(y1, y2)))) -> c6(BUBBLE(.(z1, .(y1, y2)))) by 
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, .(y4, y5))))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, .(y4, y5)))))))

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

(212)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, .(y4, y5))))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, .(y4, y5)))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, .(y4, y5))))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, .(y4, y5)))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c4_1, c_1, c1_1, c3_1, c7_1, c2_2, c5_1, c2_1


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

(213) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3))))) by 
   BUBBLE(.(z0, .(z1, .(z2, .(z3, .(y3, y4)))))) -> c6(BUBBLE(.(z1, .(z2, .(z3, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(z3, .(y3, .(y4, y5))))))) -> c6(BUBBLE(.(z1, .(z2, .(z3, .(y3, .(y4, y5)))))))
   BUBBLE(.(z0, .(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6)))))))) -> c6(BUBBLE(.(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6))))))))

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

(214)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, .(y4, y5))))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, .(y4, y5)))))))
   BUBBLE(.(z0, .(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6)))))))) -> c6(BUBBLE(.(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6))))))))
S tuples:
   LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2))))
K tuples:
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, .(y4, y5))))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, .(y4, y5)))))))
   BUBBLE(.(z0, .(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6)))))))) -> c6(BUBBLE(.(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6))))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, LAST_1, BUTLAST_1, BSORT_1

Compound Symbols:   c6_1, c9_1, c12_1, c4_1, c_1, c1_1, c3_1, c7_1, c2_2, c5_1, c2_1


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

(215) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LAST(.(z0, .(z1, .(y1, y2)))) -> c9(LAST(.(z1, .(y1, y2)))) by 
   LAST(.(z0, .(z1, .(z2, .(y2, y3))))) -> c9(LAST(.(z1, .(z2, .(y2, y3)))))

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

(216)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(.(z0, nil)) -> .(z0, nil)
   bubble(.(z0, .(z1, z2))) -> if(<=(z0, z1), .(z1, bubble(.(z0, z2))), .(z0, bubble(.(z1, z2))))
   bsort(nil) -> nil
   bsort(.(z0, z1)) -> last(.(bubble(.(z0, z1)), bsort(butlast(bubble(.(z0, z1))))))
   butlast(nil) -> nil
   butlast(.(z0, nil)) -> nil
   butlast(.(z0, .(z1, z2))) -> .(z0, butlast(.(z1, z2)))
   last(.(z0, nil)) -> z0
   last(.(z0, .(z1, z2))) -> last(.(z1, z2))
Tuples:
   BUBBLE(.(z0, .(z1, .(y1, .(y2, y3))))) -> c6(BUBBLE(.(z1, .(y1, .(y2, y3)))))
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, .(z2, z3)))), .(z0, if(<=(z1, z2), .(z2, bubble(.(z1, z3))), .(z1, bubble(.(z2, z3)))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c4(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c1(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c1(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(y2, y3)))) -> c3(BUBBLE(.(z0, .(z1, .(y2, y3)))))
   BSORT(.(z0, .(z1, .(y2, .(y3, y4))))) -> c3(BUBBLE(.(z0, .(z1, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(LAST(.(if(<=(z0, z1), .(z1, if(<=(z0, z2), .(z2, bubble(.(z0, z3))), .(z0, bubble(.(z2, z3))))), .(z0, bubble(.(z1, .(z2, z3))))), bsort(butlast(bubble(.(z0, .(z1, .(z2, z3)))))))))
   BSORT(.(z0, .(z1, .(z2, z3)))) -> c7(BUBBLE(.(z0, .(z1, .(z2, z3)))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, bubble(.(z0, nil))), .(z0, .(z1, nil))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BSORT(.(z0, .(z1, nil))) -> c2(LAST(.(if(<=(z0, z1), .(z1, .(z0, nil)), .(z0, bubble(.(z1, nil)))), bsort(butlast(bubble(.(z0, .(z1, nil))))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, .(y4, y5))))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, .(y4, y5)))))))
   BUBBLE(.(z0, .(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6)))))))) -> c6(BUBBLE(.(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6))))))))
   LAST(.(z0, .(z1, .(z2, .(y2, y3))))) -> c9(LAST(.(z1, .(z2, .(y2, y3)))))
S tuples:
   LAST(.(z0, .(z1, .(z2, .(y2, y3))))) -> c9(LAST(.(z1, .(z2, .(y2, y3)))))
K tuples:
   BUTLAST(.(z0, .(z1, .(y1, y2)))) -> c12(BUTLAST(.(z1, .(y1, y2))))
   BSORT(.(z0, .(y1, .(y2, y3)))) -> c(BUBBLE(.(z0, .(y1, .(y2, y3)))))
   BSORT(.(z0, .(y1, .(y2, .(y3, y4))))) -> c(BUBBLE(.(z0, .(y1, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, y3))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, y3)))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c5(BUBBLE(.(z0, .(z2, .(y2, .(y3, y4))))))
   BSORT(.(z0, nil)) -> c2(LAST(.(bubble(.(z0, nil)), bsort(nil))), BSORT(butlast(.(z0, nil))))
   BSORT(.(z0, nil)) -> c2(LAST(.(.(z0, nil), bsort(butlast(.(z0, nil))))), BSORT(butlast(.(z0, nil))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, y4)))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, y4))))))
   BUBBLE(.(z0, .(z1, .(z2, .(y2, .(y3, .(y4, y5))))))) -> c6(BUBBLE(.(z1, .(z2, .(y2, .(y3, .(y4, y5)))))))
   BUBBLE(.(z0, .(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6)))))))) -> c6(BUBBLE(.(z1, .(z2, .(z3, .(y3, .(y4, .(y5, y6))))))))
Defined Rule Symbols:   bubble_1, bsort_1, butlast_1, last_1

Defined Pair Symbols:   BUBBLE_1, BUTLAST_1, BSORT_1, LAST_1

Compound Symbols:   c6_1, c12_1, c4_1, c_1, c1_1, c3_1, c7_1, c2_2, c5_1, c2_1, c9_1