WORST_CASE(?,O(n^2))
proof of input_oG12RGl6Eg.trs
# AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished


The Runtime Complexity (parallel-innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, n^2).

(0) CpxRelTRS
(1) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 209 ms]
(2) CpxRelTRS
(3) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(4) CdtProblem
(5) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
(6) CdtProblem
(7) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
(8) CdtProblem
(9) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
(10) CdtProblem
(11) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
(12) CdtProblem
(13) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
(14) CdtProblem
(15) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
(16) CdtProblem
(17) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(18) CpxRelTRS
(19) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(20) CpxWeightedTrs
(21) CpxWeightedTrsRenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(22) CpxWeightedTrs
(23) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
(24) CpxTypedWeightedTrs
(25) CompletionProof [UPPER BOUND(ID), 0 ms]
(26) CpxTypedWeightedCompleteTrs
(27) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
(28) CpxTypedWeightedCompleteTrs
(29) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
(30) CpxRNTS
(31) InliningProof [UPPER BOUND(ID), 142 ms]
(32) CpxRNTS
(33) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
(34) CpxRNTS
(35) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
(36) CpxRNTS
(37) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(38) CpxRNTS
(39) IntTrsBoundProof [UPPER BOUND(ID), 232 ms]
(40) CpxRNTS
(41) IntTrsBoundProof [UPPER BOUND(ID), 74 ms]
(42) CpxRNTS
(43) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(44) CpxRNTS
(45) IntTrsBoundProof [UPPER BOUND(ID), 118 ms]
(46) CpxRNTS
(47) IntTrsBoundProof [UPPER BOUND(ID), 52 ms]
(48) CpxRNTS
(49) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(50) CpxRNTS
(51) IntTrsBoundProof [UPPER BOUND(ID), 392 ms]
(52) CpxRNTS
(53) IntTrsBoundProof [UPPER BOUND(ID), 84 ms]
(54) CpxRNTS
(55) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(56) CpxRNTS
(57) IntTrsBoundProof [UPPER BOUND(ID), 261 ms]
(58) CpxRNTS
(59) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
(60) CpxRNTS
(61) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(62) CpxRNTS
(63) IntTrsBoundProof [UPPER BOUND(ID), 1849 ms]
(64) CpxRNTS
(65) IntTrsBoundProof [UPPER BOUND(ID), 473 ms]
(66) CpxRNTS
(67) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(68) CpxRNTS
(69) IntTrsBoundProof [UPPER BOUND(ID), 2996 ms]
(70) CpxRNTS
(71) IntTrsBoundProof [UPPER BOUND(ID), 634 ms]
(72) CpxRNTS
(73) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(74) CpxRNTS
(75) IntTrsBoundProof [UPPER BOUND(ID), 351 ms]
(76) CpxRNTS
(77) IntTrsBoundProof [UPPER BOUND(ID), 95 ms]
(78) CpxRNTS
(79) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(80) CpxRNTS
(81) IntTrsBoundProof [UPPER BOUND(ID), 453 ms]
(82) CpxRNTS
(83) IntTrsBoundProof [UPPER BOUND(ID), 217 ms]
(84) CpxRNTS
(85) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(86) CpxRNTS
(87) IntTrsBoundProof [UPPER BOUND(ID), 209 ms]
(88) CpxRNTS
(89) IntTrsBoundProof [UPPER BOUND(ID), 43 ms]
(90) CpxRNTS
(91) FinalProof [FINISHED, 0 ms]
(92) BOUNDS(1, n^2)


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

(0)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, n^2).


The TRS R consists of the following rules:

   bsort(S(x'), Cons(x, xs)) -> bsort(x', bubble(x, xs))
   len(Cons(x, xs)) -> +(S(0), len(xs))
   bubble(x', Cons(x, xs)) -> bubble[Ite][False][Ite](<(x', x), x', Cons(x, xs))
   len(Nil) -> 0
   bubble(x, Nil) -> Cons(x, Nil)
   bsort(0, xs) -> xs
   bubblesort(xs) -> bsort(len(xs), xs)

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

   +(x, S(0)) -> S(x)
   +(S(0), y) -> S(y)
   <(S(x), S(y)) -> <(x, y)
   <(0, S(y)) -> True
   <(x, 0) -> False
   bubble[Ite][False][Ite](False, x', Cons(x, xs)) -> Cons(x, bubble(x', xs))
   bubble[Ite][False][Ite](True, x', Cons(x, xs)) -> Cons(x', bubble(x, xs))

Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(1) SInnermostTerminationProof (BOTH CONCRETE BOUNDS(ID, ID))
proved innermost termination of relative rules
----------------------------------------

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


The TRS R consists of the following rules:

   bsort(S(x'), Cons(x, xs)) -> bsort(x', bubble(x, xs))
   len(Cons(x, xs)) -> +(S(0), len(xs))
   bubble(x', Cons(x, xs)) -> bubble[Ite][False][Ite](<(x', x), x', Cons(x, xs))
   len(Nil) -> 0
   bubble(x, Nil) -> Cons(x, Nil)
   bsort(0, xs) -> xs
   bubblesort(xs) -> bsort(len(xs), xs)

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

   +(x, S(0)) -> S(x)
   +(S(0), y) -> S(y)
   <(S(x), S(y)) -> <(x, y)
   <(0, S(y)) -> True
   <(x, 0) -> False
   bubble[Ite][False][Ite](False, x', Cons(x, xs)) -> Cons(x, bubble(x', xs))
   bubble[Ite][False][Ite](True, x', Cons(x, xs)) -> Cons(x', bubble(x, xs))

Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

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

(4)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, S(0)) -> S(z0)
   +(S(0), z0) -> S(z0)
   <(S(z0), S(z1)) -> <(z0, z1)
   <(0, S(z0)) -> True
   <(z0, 0) -> False
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2))
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2))
   bsort(S(z0), Cons(z1, z2)) -> bsort(z0, bubble(z1, z2))
   bsort(0, z0) -> z0
   len(Cons(z0, z1)) -> +(S(0), len(z1))
   len(Nil) -> 0
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](<(z0, z1), z0, Cons(z1, z2))
   bubble(z0, Nil) -> Cons(z0, Nil)
   bubblesort(z0) -> bsort(len(z0), z0)
Tuples:
   +'(z0, S(0)) -> c
   +'(S(0), z0) -> c1
   <'(S(z0), S(z1)) -> c2(<'(z0, z1))
   <'(0, S(z0)) -> c3
   <'(z0, 0) -> c4
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2))
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2))
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BSORT(0, z0) -> c8
   LEN(Cons(z0, z1)) -> c9(+'(S(0), len(z1)), LEN(z1))
   LEN(Nil) -> c10
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   BUBBLESORT(z0) -> c13(BSORT(len(z0), z0), LEN(z0))
S tuples:
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BSORT(0, z0) -> c8
   LEN(Cons(z0, z1)) -> c9(+'(S(0), len(z1)), LEN(z1))
   LEN(Nil) -> c10
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   BUBBLESORT(z0) -> c13(BSORT(len(z0), z0), LEN(z0))
K tuples:none
Defined Rule Symbols:   bsort_2, len_1, bubble_2, bubblesort_1, +_2, <_2, bubble[Ite][False][Ite]_3

Defined Pair Symbols:   +'_2, <'_2, BUBBLE[ITE][FALSE][ITE]_3, BSORT_2, LEN_1, BUBBLE_2, BUBBLESORT_1

Compound Symbols:   c, c1, c2_1, c3, c4, c5_1, c6_1, c7_2, c8, c9_2, c10, c11_2, c12, c13_2


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

(5) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 6 trailing nodes:
   BSORT(0, z0) -> c8
   +'(S(0), z0) -> c1
   LEN(Nil) -> c10
   +'(z0, S(0)) -> c
   <'(0, S(z0)) -> c3
   <'(z0, 0) -> c4

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

(6)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, S(0)) -> S(z0)
   +(S(0), z0) -> S(z0)
   <(S(z0), S(z1)) -> <(z0, z1)
   <(0, S(z0)) -> True
   <(z0, 0) -> False
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2))
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2))
   bsort(S(z0), Cons(z1, z2)) -> bsort(z0, bubble(z1, z2))
   bsort(0, z0) -> z0
   len(Cons(z0, z1)) -> +(S(0), len(z1))
   len(Nil) -> 0
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](<(z0, z1), z0, Cons(z1, z2))
   bubble(z0, Nil) -> Cons(z0, Nil)
   bubblesort(z0) -> bsort(len(z0), z0)
Tuples:
   <'(S(z0), S(z1)) -> c2(<'(z0, z1))
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2))
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2))
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   LEN(Cons(z0, z1)) -> c9(+'(S(0), len(z1)), LEN(z1))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   BUBBLESORT(z0) -> c13(BSORT(len(z0), z0), LEN(z0))
S tuples:
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   LEN(Cons(z0, z1)) -> c9(+'(S(0), len(z1)), LEN(z1))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   BUBBLESORT(z0) -> c13(BSORT(len(z0), z0), LEN(z0))
K tuples:none
Defined Rule Symbols:   bsort_2, len_1, bubble_2, bubblesort_1, +_2, <_2, bubble[Ite][False][Ite]_3

Defined Pair Symbols:   <'_2, BUBBLE[ITE][FALSE][ITE]_3, BSORT_2, LEN_1, BUBBLE_2, BUBBLESORT_1

Compound Symbols:   c2_1, c5_1, c6_1, c7_2, c9_2, c11_2, c12, c13_2


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

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

(8)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, S(0)) -> S(z0)
   +(S(0), z0) -> S(z0)
   <(S(z0), S(z1)) -> <(z0, z1)
   <(0, S(z0)) -> True
   <(z0, 0) -> False
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2))
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2))
   bsort(S(z0), Cons(z1, z2)) -> bsort(z0, bubble(z1, z2))
   bsort(0, z0) -> z0
   len(Cons(z0, z1)) -> +(S(0), len(z1))
   len(Nil) -> 0
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](<(z0, z1), z0, Cons(z1, z2))
   bubble(z0, Nil) -> Cons(z0, Nil)
   bubblesort(z0) -> bsort(len(z0), z0)
Tuples:
   <'(S(z0), S(z1)) -> c2(<'(z0, z1))
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2))
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2))
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   BUBBLESORT(z0) -> c13(BSORT(len(z0), z0), LEN(z0))
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
S tuples:
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   BUBBLESORT(z0) -> c13(BSORT(len(z0), z0), LEN(z0))
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
K tuples:none
Defined Rule Symbols:   bsort_2, len_1, bubble_2, bubblesort_1, +_2, <_2, bubble[Ite][False][Ite]_3

Defined Pair Symbols:   <'_2, BUBBLE[ITE][FALSE][ITE]_3, BSORT_2, BUBBLE_2, BUBBLESORT_1, LEN_1

Compound Symbols:   c2_1, c5_1, c6_1, c7_2, c11_2, c12, c13_2, c9_1


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

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

(10)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, S(0)) -> S(z0)
   +(S(0), z0) -> S(z0)
   <(S(z0), S(z1)) -> <(z0, z1)
   <(0, S(z0)) -> True
   <(z0, 0) -> False
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2))
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2))
   bsort(S(z0), Cons(z1, z2)) -> bsort(z0, bubble(z1, z2))
   bsort(0, z0) -> z0
   len(Cons(z0, z1)) -> +(S(0), len(z1))
   len(Nil) -> 0
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](<(z0, z1), z0, Cons(z1, z2))
   bubble(z0, Nil) -> Cons(z0, Nil)
   bubblesort(z0) -> bsort(len(z0), z0)
Tuples:
   <'(S(z0), S(z1)) -> c2(<'(z0, z1))
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2))
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2))
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))
   BUBBLESORT(z0) -> c(LEN(z0))
S tuples:
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))
   BUBBLESORT(z0) -> c(LEN(z0))
K tuples:none
Defined Rule Symbols:   bsort_2, len_1, bubble_2, bubblesort_1, +_2, <_2, bubble[Ite][False][Ite]_3

Defined Pair Symbols:   <'_2, BUBBLE[ITE][FALSE][ITE]_3, BSORT_2, BUBBLE_2, LEN_1, BUBBLESORT_1

Compound Symbols:   c2_1, c5_1, c6_1, c7_2, c11_2, c12, c9_1, c_1


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

(11) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   BUBBLESORT(z0) -> c(LEN(z0))

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

(12)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, S(0)) -> S(z0)
   +(S(0), z0) -> S(z0)
   <(S(z0), S(z1)) -> <(z0, z1)
   <(0, S(z0)) -> True
   <(z0, 0) -> False
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2))
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2))
   bsort(S(z0), Cons(z1, z2)) -> bsort(z0, bubble(z1, z2))
   bsort(0, z0) -> z0
   len(Cons(z0, z1)) -> +(S(0), len(z1))
   len(Nil) -> 0
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](<(z0, z1), z0, Cons(z1, z2))
   bubble(z0, Nil) -> Cons(z0, Nil)
   bubblesort(z0) -> bsort(len(z0), z0)
Tuples:
   <'(S(z0), S(z1)) -> c2(<'(z0, z1))
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2))
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2))
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))
S tuples:
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))
K tuples:none
Defined Rule Symbols:   bsort_2, len_1, bubble_2, bubblesort_1, +_2, <_2, bubble[Ite][False][Ite]_3

Defined Pair Symbols:   <'_2, BUBBLE[ITE][FALSE][ITE]_3, BSORT_2, BUBBLE_2, LEN_1, BUBBLESORT_1

Compound Symbols:   c2_1, c5_1, c6_1, c7_2, c11_2, c12, c9_1, c_1


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

(13) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))

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

(14)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, S(0)) -> S(z0)
   +(S(0), z0) -> S(z0)
   <(S(z0), S(z1)) -> <(z0, z1)
   <(0, S(z0)) -> True
   <(z0, 0) -> False
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2))
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2))
   bsort(S(z0), Cons(z1, z2)) -> bsort(z0, bubble(z1, z2))
   bsort(0, z0) -> z0
   len(Cons(z0, z1)) -> +(S(0), len(z1))
   len(Nil) -> 0
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](<(z0, z1), z0, Cons(z1, z2))
   bubble(z0, Nil) -> Cons(z0, Nil)
   bubblesort(z0) -> bsort(len(z0), z0)
Tuples:
   <'(S(z0), S(z1)) -> c2(<'(z0, z1))
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2))
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2))
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))
S tuples:
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
K tuples:
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))
Defined Rule Symbols:   bsort_2, len_1, bubble_2, bubblesort_1, +_2, <_2, bubble[Ite][False][Ite]_3

Defined Pair Symbols:   <'_2, BUBBLE[ITE][FALSE][ITE]_3, BSORT_2, BUBBLE_2, LEN_1, BUBBLESORT_1

Compound Symbols:   c2_1, c5_1, c6_1, c7_2, c11_2, c12, c9_1, c_1


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

(15) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   bsort(S(z0), Cons(z1, z2)) -> bsort(z0, bubble(z1, z2))
   bsort(0, z0) -> z0
   bubblesort(z0) -> bsort(len(z0), z0)

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

(16)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](<(z0, z1), z0, Cons(z1, z2))
   bubble(z0, Nil) -> Cons(z0, Nil)
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2))
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2))
   <(S(z0), S(z1)) -> <(z0, z1)
   <(0, S(z0)) -> True
   <(z0, 0) -> False
   len(Cons(z0, z1)) -> +(S(0), len(z1))
   len(Nil) -> 0
   +(z0, S(0)) -> S(z0)
   +(S(0), z0) -> S(z0)
Tuples:
   <'(S(z0), S(z1)) -> c2(<'(z0, z1))
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2))
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2))
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))
S tuples:
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   LEN(Cons(z0, z1)) -> c9(LEN(z1))
K tuples:
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))
Defined Rule Symbols:   bubble_2, bubble[Ite][False][Ite]_3, <_2, len_1, +_2

Defined Pair Symbols:   <'_2, BUBBLE[ITE][FALSE][ITE]_3, BSORT_2, BUBBLE_2, LEN_1, BUBBLESORT_1

Compound Symbols:   c2_1, c5_1, c6_1, c7_2, c11_2, c12, c9_1, c_1


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

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

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


The TRS R consists of the following rules:

   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2))
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1))
   BUBBLE(z0, Nil) -> c12
   LEN(Cons(z0, z1)) -> c9(LEN(z1))

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

   <'(S(z0), S(z1)) -> c2(<'(z0, z1))
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2))
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2))
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0))
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](<(z0, z1), z0, Cons(z1, z2))
   bubble(z0, Nil) -> Cons(z0, Nil)
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2))
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2))
   <(S(z0), S(z1)) -> <(z0, z1)
   <(0, S(z0)) -> True
   <(z0, 0) -> False
   len(Cons(z0, z1)) -> +(S(0), len(z1))
   len(Nil) -> 0
   +(z0, S(0)) -> S(z0)
   +(S(0), z0) -> S(z0)

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

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

(20)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, n^2).


The TRS R consists of the following rules:

   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2)) [1]
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](<(z0, z1), z0, Cons(z1, z2)), <'(z0, z1)) [1]
   BUBBLE(z0, Nil) -> c12 [1]
   LEN(Cons(z0, z1)) -> c9(LEN(z1)) [1]
   <'(S(z0), S(z1)) -> c2(<'(z0, z1)) [0]
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2)) [0]
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2)) [0]
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0)) [0]
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](<(z0, z1), z0, Cons(z1, z2)) [0]
   bubble(z0, Nil) -> Cons(z0, Nil) [0]
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2)) [0]
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2)) [0]
   <(S(z0), S(z1)) -> <(z0, z1) [0]
   <(0, S(z0)) -> True [0]
   <(z0, 0) -> False [0]
   len(Cons(z0, z1)) -> +(S(0), len(z1)) [0]
   len(Nil) -> 0 [0]
   +(z0, S(0)) -> S(z0) [0]
   +(S(0), z0) -> S(z0) [0]

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

(21) CpxWeightedTrsRenamingProof (BOTH BOUNDS(ID, ID))
Renamed defined symbols to avoid conflicts with arithmetic symbols:

< => lt
+ => plus

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

(22)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, n^2).


The TRS R consists of the following rules:

   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2)) [1]
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](lt(z0, z1), z0, Cons(z1, z2)), <'(z0, z1)) [1]
   BUBBLE(z0, Nil) -> c12 [1]
   LEN(Cons(z0, z1)) -> c9(LEN(z1)) [1]
   <'(S(z0), S(z1)) -> c2(<'(z0, z1)) [0]
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2)) [0]
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2)) [0]
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0)) [0]
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](lt(z0, z1), z0, Cons(z1, z2)) [0]
   bubble(z0, Nil) -> Cons(z0, Nil) [0]
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2)) [0]
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2)) [0]
   lt(S(z0), S(z1)) -> lt(z0, z1) [0]
   lt(0, S(z0)) -> True [0]
   lt(z0, 0) -> False [0]
   len(Cons(z0, z1)) -> plus(S(0), len(z1)) [0]
   len(Nil) -> 0 [0]
   plus(z0, S(0)) -> S(z0) [0]
   plus(S(0), z0) -> S(z0) [0]

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

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

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

   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2)) [1]
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](lt(z0, z1), z0, Cons(z1, z2)), <'(z0, z1)) [1]
   BUBBLE(z0, Nil) -> c12 [1]
   LEN(Cons(z0, z1)) -> c9(LEN(z1)) [1]
   <'(S(z0), S(z1)) -> c2(<'(z0, z1)) [0]
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2)) [0]
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2)) [0]
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0)) [0]
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](lt(z0, z1), z0, Cons(z1, z2)) [0]
   bubble(z0, Nil) -> Cons(z0, Nil) [0]
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2)) [0]
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2)) [0]
   lt(S(z0), S(z1)) -> lt(z0, z1) [0]
   lt(0, S(z0)) -> True [0]
   lt(z0, 0) -> False [0]
   len(Cons(z0, z1)) -> plus(S(0), len(z1)) [0]
   len(Nil) -> 0 [0]
   plus(z0, S(0)) -> S(z0) [0]
   plus(S(0), z0) -> S(z0) [0]

The TRS has the following type information:
BSORT :: S:0 -> Cons:Nil -> c7
S :: S:0 -> S:0
Cons :: S:0 -> Cons:Nil -> Cons:Nil
c7 :: c7 -> c11:c12 -> c7
bubble :: S:0 -> Cons:Nil -> Cons:Nil
BUBBLE :: S:0 -> Cons:Nil -> c11:c12
c11 :: c5:c6 -> c2 -> c11:c12
BUBBLE[ITE][FALSE][ITE] :: False:True -> S:0 -> Cons:Nil -> c5:c6
lt :: S:0 -> S:0 -> False:True
<' :: S:0 -> S:0 -> c2
Nil :: Cons:Nil
c12 :: c11:c12
LEN :: Cons:Nil -> c9
c9 :: c9 -> c9
c2 :: c2 -> c2
False :: False:True
c5 :: c11:c12 -> c5:c6
True :: False:True
c6 :: c11:c12 -> c5:c6
BUBBLESORT :: Cons:Nil -> c
c :: c7 -> c
len :: Cons:Nil -> S:0
bubble[Ite][False][Ite] :: False:True -> S:0 -> Cons:Nil -> Cons:Nil
0 :: S:0
plus :: S:0 -> S:0 -> S:0

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

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

   BSORT_2
   BUBBLE_2
   LEN_1

(c) The following functions are completely defined:

   <'_2
   BUBBLE[ITE][FALSE][ITE]_3
   BUBBLESORT_1
   bubble_2
   bubble[Ite][False][Ite]_3
   lt_2
   len_1
   plus_2

Due to the following rules being added:

   <'(v0, v1) -> const2 [0]
   BUBBLE[ITE][FALSE][ITE](v0, v1, v2) -> const1 [0]
   BUBBLESORT(v0) -> const4 [0]
   bubble(v0, v1) -> Nil [0]
   bubble[Ite][False][Ite](v0, v1, v2) -> Nil [0]
   lt(v0, v1) -> null_lt [0]
   len(v0) -> 0 [0]
   plus(v0, v1) -> 0 [0]

And the following fresh constants:    const2, const1, const4, null_lt, const, const3

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

(26)
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(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, bubble(z1, z2)), BUBBLE(z1, z2)) [1]
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](lt(z0, z1), z0, Cons(z1, z2)), <'(z0, z1)) [1]
   BUBBLE(z0, Nil) -> c12 [1]
   LEN(Cons(z0, z1)) -> c9(LEN(z1)) [1]
   <'(S(z0), S(z1)) -> c2(<'(z0, z1)) [0]
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2)) [0]
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2)) [0]
   BUBBLESORT(z0) -> c(BSORT(len(z0), z0)) [0]
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](lt(z0, z1), z0, Cons(z1, z2)) [0]
   bubble(z0, Nil) -> Cons(z0, Nil) [0]
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2)) [0]
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2)) [0]
   lt(S(z0), S(z1)) -> lt(z0, z1) [0]
   lt(0, S(z0)) -> True [0]
   lt(z0, 0) -> False [0]
   len(Cons(z0, z1)) -> plus(S(0), len(z1)) [0]
   len(Nil) -> 0 [0]
   plus(z0, S(0)) -> S(z0) [0]
   plus(S(0), z0) -> S(z0) [0]
   <'(v0, v1) -> const2 [0]
   BUBBLE[ITE][FALSE][ITE](v0, v1, v2) -> const1 [0]
   BUBBLESORT(v0) -> const4 [0]
   bubble(v0, v1) -> Nil [0]
   bubble[Ite][False][Ite](v0, v1, v2) -> Nil [0]
   lt(v0, v1) -> null_lt [0]
   len(v0) -> 0 [0]
   plus(v0, v1) -> 0 [0]

The TRS has the following type information:
BSORT :: S:0 -> Cons:Nil -> c7
S :: S:0 -> S:0
Cons :: S:0 -> Cons:Nil -> Cons:Nil
c7 :: c7 -> c11:c12 -> c7
bubble :: S:0 -> Cons:Nil -> Cons:Nil
BUBBLE :: S:0 -> Cons:Nil -> c11:c12
c11 :: c5:c6:const1 -> c2:const2 -> c11:c12
BUBBLE[ITE][FALSE][ITE] :: False:True:null_lt -> S:0 -> Cons:Nil -> c5:c6:const1
lt :: S:0 -> S:0 -> False:True:null_lt
<' :: S:0 -> S:0 -> c2:const2
Nil :: Cons:Nil
c12 :: c11:c12
LEN :: Cons:Nil -> c9
c9 :: c9 -> c9
c2 :: c2:const2 -> c2:const2
False :: False:True:null_lt
c5 :: c11:c12 -> c5:c6:const1
True :: False:True:null_lt
c6 :: c11:c12 -> c5:c6:const1
BUBBLESORT :: Cons:Nil -> c:const4
c :: c7 -> c:const4
len :: Cons:Nil -> S:0
bubble[Ite][False][Ite] :: False:True:null_lt -> S:0 -> Cons:Nil -> Cons:Nil
0 :: S:0
plus :: S:0 -> S:0 -> S:0
const2 :: c2:const2
const1 :: c5:c6:const1
const4 :: c:const4
null_lt :: False:True:null_lt
const :: c7
const3 :: c9

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

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

(28)
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(S(z0), Cons(z1, Cons(z1', z2'))) -> c7(BSORT(z0, bubble[Ite][False][Ite](lt(z1, z1'), z1, Cons(z1', z2'))), BUBBLE(z1, Cons(z1', z2'))) [1]
   BSORT(S(z0), Cons(z1, Nil)) -> c7(BSORT(z0, Cons(z1, Nil)), BUBBLE(z1, Nil)) [1]
   BSORT(S(z0), Cons(z1, z2)) -> c7(BSORT(z0, Nil), BUBBLE(z1, z2)) [1]
   BUBBLE(S(z0'), Cons(S(z1''), z2)) -> c11(BUBBLE[ITE][FALSE][ITE](lt(z0', z1''), S(z0'), Cons(S(z1''), z2)), <'(S(z0'), S(z1''))) [1]
   BUBBLE(0, Cons(S(z0''), z2)) -> c11(BUBBLE[ITE][FALSE][ITE](True, 0, Cons(S(z0''), z2)), <'(0, S(z0''))) [1]
   BUBBLE(z0, Cons(0, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](False, z0, Cons(0, z2)), <'(z0, 0)) [1]
   BUBBLE(z0, Cons(z1, z2)) -> c11(BUBBLE[ITE][FALSE][ITE](null_lt, z0, Cons(z1, z2)), <'(z0, z1)) [1]
   BUBBLE(z0, Nil) -> c12 [1]
   LEN(Cons(z0, z1)) -> c9(LEN(z1)) [1]
   <'(S(z0), S(z1)) -> c2(<'(z0, z1)) [0]
   BUBBLE[ITE][FALSE][ITE](False, z0, Cons(z1, z2)) -> c5(BUBBLE(z0, z2)) [0]
   BUBBLE[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c6(BUBBLE(z1, z2)) [0]
   BUBBLESORT(Cons(z01, z11)) -> c(BSORT(plus(S(0), len(z11)), Cons(z01, z11))) [0]
   BUBBLESORT(Nil) -> c(BSORT(0, Nil)) [0]
   BUBBLESORT(z0) -> c(BSORT(0, z0)) [0]
   bubble(S(z02), Cons(S(z12), z2)) -> bubble[Ite][False][Ite](lt(z02, z12), S(z02), Cons(S(z12), z2)) [0]
   bubble(0, Cons(S(z03), z2)) -> bubble[Ite][False][Ite](True, 0, Cons(S(z03), z2)) [0]
   bubble(z0, Cons(0, z2)) -> bubble[Ite][False][Ite](False, z0, Cons(0, z2)) [0]
   bubble(z0, Cons(z1, z2)) -> bubble[Ite][False][Ite](null_lt, z0, Cons(z1, z2)) [0]
   bubble(z0, Nil) -> Cons(z0, Nil) [0]
   bubble[Ite][False][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, bubble(z0, z2)) [0]
   bubble[Ite][False][Ite](True, z0, Cons(z1, z2)) -> Cons(z0, bubble(z1, z2)) [0]
   lt(S(z0), S(z1)) -> lt(z0, z1) [0]
   lt(0, S(z0)) -> True [0]
   lt(z0, 0) -> False [0]
   len(Cons(z0, Cons(z04, z13))) -> plus(S(0), plus(S(0), len(z13))) [0]
   len(Cons(z0, Nil)) -> plus(S(0), 0) [0]
   len(Cons(z0, z1)) -> plus(S(0), 0) [0]
   len(Nil) -> 0 [0]
   plus(z0, S(0)) -> S(z0) [0]
   plus(S(0), z0) -> S(z0) [0]
   <'(v0, v1) -> const2 [0]
   BUBBLE[ITE][FALSE][ITE](v0, v1, v2) -> const1 [0]
   BUBBLESORT(v0) -> const4 [0]
   bubble(v0, v1) -> Nil [0]
   bubble[Ite][False][Ite](v0, v1, v2) -> Nil [0]
   lt(v0, v1) -> null_lt [0]
   len(v0) -> 0 [0]
   plus(v0, v1) -> 0 [0]

The TRS has the following type information:
BSORT :: S:0 -> Cons:Nil -> c7
S :: S:0 -> S:0
Cons :: S:0 -> Cons:Nil -> Cons:Nil
c7 :: c7 -> c11:c12 -> c7
bubble :: S:0 -> Cons:Nil -> Cons:Nil
BUBBLE :: S:0 -> Cons:Nil -> c11:c12
c11 :: c5:c6:const1 -> c2:const2 -> c11:c12
BUBBLE[ITE][FALSE][ITE] :: False:True:null_lt -> S:0 -> Cons:Nil -> c5:c6:const1
lt :: S:0 -> S:0 -> False:True:null_lt
<' :: S:0 -> S:0 -> c2:const2
Nil :: Cons:Nil
c12 :: c11:c12
LEN :: Cons:Nil -> c9
c9 :: c9 -> c9
c2 :: c2:const2 -> c2:const2
False :: False:True:null_lt
c5 :: c11:c12 -> c5:c6:const1
True :: False:True:null_lt
c6 :: c11:c12 -> c5:c6:const1
BUBBLESORT :: Cons:Nil -> c:const4
c :: c7 -> c:const4
len :: Cons:Nil -> S:0
bubble[Ite][False][Ite] :: False:True:null_lt -> S:0 -> Cons:Nil -> Cons:Nil
0 :: S:0
plus :: S:0 -> S:0 -> S:0
const2 :: c2:const2
const1 :: c5:c6:const1
const4 :: c:const4
null_lt :: False:True:null_lt
const :: c7
const3 :: c9

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

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

   Nil => 0
   c12 => 0
   False => 1
   True => 2
   0 => 0
   const2 => 0
   const1 => 0
   const4 => 0
   null_lt => 0
   const => 0
   const3 => 0

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

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

   <'(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   <'(z, z') -{ 0 }-> 1 + <'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z0, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z = 1 + z0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z0 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z0, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z = 1 + z0, z0 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z0, 1 + z1 + 0) + BUBBLE(z1, 0) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1 + 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z = z0, z0 >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z0', z1''), 1 + z0', 1 + (1 + z1'') + z2) + <'(1 + z0', 1 + z1'') :|: z' = 1 + (1 + z1'') + z2, z0' >= 0, z = 1 + z0', z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + <'(0, 1 + z0'') :|: z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z0, 1 + 0 + z2) + <'(z0, 0) :|: z = z0, z0 >= 0, z2 >= 0, z' = 1 + 0 + z2
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z0, 1 + z1 + z2) + <'(z0, z1) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z0) :|: z = z0, z0 >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z0, z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z02, z12), 1 + z02, 1 + (1 + z12) + z2) :|: z = 1 + z02, z' = 1 + (1 + z12) + z2, z02 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z0, 1 + 0 + z2) :|: z = z0, z0 >= 0, z2 >= 0, z' = 1 + 0 + z2
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z0, 1 + z1 + z2) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   bubble(z, z') -{ 0 }-> 1 + z0 + 0 :|: z = z0, z0 >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z0 + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z0, z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> plus(1 + 0, 0) :|: z0 >= 0, z = 1 + z0 + 0
   len(z) -{ 0 }-> plus(1 + 0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   lt(z, z') -{ 0 }-> lt(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   lt(z, z') -{ 0 }-> 2 :|: z0 >= 0, z' = 1 + z0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z = z0, z0 >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   plus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   plus(z, z') -{ 0 }-> 1 + z0 :|: z = z0, z' = 1 + 0, z0 >= 0
   plus(z, z') -{ 0 }-> 1 + z0 :|: z = 1 + 0, z0 >= 0, z' = z0


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

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

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   <'(z, z') -{ 0 }-> 1 + <'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z0, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z = 1 + z0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z0 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z0, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z = 1 + z0, z0 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z0, 1 + z1 + 0) + BUBBLE(z1, 0) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1 + 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z = z0, z0 >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z0', z1''), 1 + z0', 1 + (1 + z1'') + z2) + <'(1 + z0', 1 + z1'') :|: z' = 1 + (1 + z1'') + z2, z0' >= 0, z = 1 + z0', z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + <'(0, 1 + z0'') :|: z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z0, 1 + 0 + z2) + <'(z0, 0) :|: z = z0, z0 >= 0, z2 >= 0, z' = 1 + 0 + z2
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z0, 1 + z1 + z2) + <'(z0, z1) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z0) :|: z = z0, z0 >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z0, z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z02, z12), 1 + z02, 1 + (1 + z12) + z2) :|: z = 1 + z02, z' = 1 + (1 + z12) + z2, z02 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z0, 1 + 0 + z2) :|: z = z0, z0 >= 0, z2 >= 0, z' = 1 + 0 + z2
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z0, 1 + z1 + z2) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   bubble(z, z') -{ 0 }-> 1 + z0 + 0 :|: z = z0, z0 >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z0 + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z0, z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   len(z) -{ 0 }-> 0 :|: z0 >= 0, z = 1 + z0 + 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z0 >= 0, z = 1 + z0 + 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   lt(z, z') -{ 0 }-> 2 :|: z0 >= 0, z' = 1 + z0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z = z0, z0 >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   plus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   plus(z, z') -{ 0 }-> 1 + z0 :|: z = z0, z' = 1 + 0, z0 >= 0
   plus(z, z') -{ 0 }-> 1 + z0 :|: z = 1 + 0, z0 >= 0, z' = z0


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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + <'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + <'(1 + (z - 1), 1 + z1'') :|: z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + <'(0, 1 + z0'') :|: z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + <'(z, 0) :|: z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + <'(z, z1) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0


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

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

   { <' }
   { LEN }
   { lt }
   { plus }
   { BUBBLE, BUBBLE[ITE][FALSE][ITE] }
   { bubble[Ite][False][Ite], bubble }
   { len }
   { BSORT }
   { BUBBLESORT }

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + <'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + <'(1 + (z - 1), 1 + z1'') :|: z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + <'(0, 1 + z0'') :|: z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + <'(z, 0) :|: z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + <'(z, z1) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {<'}, {LEN}, {lt}, {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + <'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + <'(1 + (z - 1), 1 + z1'') :|: z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + <'(0, 1 + z0'') :|: z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + <'(z, 0) :|: z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + <'(z, z1) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {<'}, {LEN}, {lt}, {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + <'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + <'(1 + (z - 1), 1 + z1'') :|: z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + <'(0, 1 + z0'') :|: z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + <'(z, 0) :|: z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + <'(z, z1) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {<'}, {LEN}, {lt}, {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: ?, size: O(n^1) [z']

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

(41) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + <'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + <'(1 + (z - 1), 1 + z1'') :|: z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + <'(0, 1 + z0'') :|: z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + <'(z, 0) :|: z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + <'(z, z1) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {LEN}, {lt}, {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {LEN}, {lt}, {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {LEN}, {lt}, {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: ?, size: O(1) [0]

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

(47) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 }-> 1 + LEN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {lt}, {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {lt}, {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {lt}, {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: ?, size: O(1) [2]

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

(53) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](lt(z1, z1'), z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](lt(z - 1, z1''), 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](lt(z - 1, z12), 1 + (z - 1), 1 + (1 + z12) + z2) :|: z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](s4, z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](s5, 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](s6, 1 + (z - 1), 1 + (1 + z12) + z2) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](s4, z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](s5, 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](s6, 1 + (z - 1), 1 + (1 + z12) + z2) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {plus}, {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: ?, size: O(n^1) [z + z']

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

(59) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](s4, z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](s5, 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](s6, 1 + (z - 1), 1 + (1 + z12) + z2) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](s4, z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](s5, 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](s6, 1 + (z - 1), 1 + (1 + z12) + z2) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: BUBBLE
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 3*z' + 8*z'^2

Computed SIZE bound using KoAT for: BUBBLE[ITE][FALSE][ITE]
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 2 + 6*z'' + 16*z''^2

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](s4, z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](s5, 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](s6, 1 + (z - 1), 1 + (1 + z12) + z2) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {BUBBLE,BUBBLE[ITE][FALSE][ITE]}, {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: ?, size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: ?, size: O(n^2) [2 + 6*z'' + 16*z''^2]

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

(65) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](s4, z1, 1 + z1' + z2')) + BUBBLE(z1, 1 + z1' + z2') :|: s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 0) + BUBBLE(z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 1 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + BUBBLE(z' - 1, 0) :|: z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](s5, 1 + (z - 1), 1 + (1 + z1'') + z2) + s :|: s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](2, 0, 1 + (1 + z0'') + z2) + s' :|: s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](1, z, 1 + 0 + (z' - 1)) + s'' :|: s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 1 + BUBBLE[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s1 :|: s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + BUBBLE(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](s6, 1 + (z - 1), 1 + (1 + z12) + z2) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 4 + z1' + z2' }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](s4, z1, 1 + z1' + z2')) + s8 :|: s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 3 + z2 }-> 1 + BSORT(z - 1, 0) + s10 :|: s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 3 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + s9 :|: s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](s6, 1 + (z - 1), 1 + (1 + z12) + z2) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: bubble[Ite][False][Ite]
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 1 + z' + z''

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 4 + z1' + z2' }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](s4, z1, 1 + z1' + z2')) + s8 :|: s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 3 + z2 }-> 1 + BSORT(z - 1, 0) + s10 :|: s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 3 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + s9 :|: s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](s6, 1 + (z - 1), 1 + (1 + z12) + z2) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {bubble[Ite][False][Ite],bubble}, {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: ?, size: O(n^1) [1 + z' + z'']
  bubble: runtime: ?, size: O(n^1) [1 + z + z']

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

(71) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 4 + z1' + z2' }-> 1 + BSORT(z - 1, bubble[Ite][False][Ite](s4, z1, 1 + z1' + z2')) + s8 :|: s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 3 + z2 }-> 1 + BSORT(z - 1, 0) + s10 :|: s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 3 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + s9 :|: s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](s6, 1 + (z - 1), 1 + (1 + z12) + z2) :|: s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](2, 0, 1 + (1 + z03) + z2) :|: z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](1, z, 1 + 0 + (z' - 1)) :|: z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> bubble[Ite][False][Ite](0, z, 1 + z1 + z2) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + bubble(z1, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + bubble(z', z2) :|: z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 4 + z1' + z2' }-> 1 + BSORT(z - 1, s17) + s8 :|: s17 >= 0, s17 <= z1 + (1 + z1' + z2') + 1, s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 3 + z2 }-> 1 + BSORT(z - 1, 0) + s10 :|: s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 3 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + s9 :|: s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 1 + (z - 1) + (1 + (1 + z12) + z2) + 1, s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s19 :|: s19 >= 0, s19 <= 0 + (1 + (1 + z03) + z2) + 1, z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z + (1 + 0 + (z' - 1)) + 1, z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> s21 :|: s21 >= 0, s21 <= z + (1 + z1 + z2) + 1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + s23 :|: s23 >= 0, s23 <= z1 + z2 + 1, z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + s22 :|: s22 >= 0, s22 <= z' + z2 + 1, z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']

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

(75) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 4 + z1' + z2' }-> 1 + BSORT(z - 1, s17) + s8 :|: s17 >= 0, s17 <= z1 + (1 + z1' + z2') + 1, s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 3 + z2 }-> 1 + BSORT(z - 1, 0) + s10 :|: s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 3 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + s9 :|: s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 1 + (z - 1) + (1 + (1 + z12) + z2) + 1, s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s19 :|: s19 >= 0, s19 <= 0 + (1 + (1 + z03) + z2) + 1, z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z + (1 + 0 + (z' - 1)) + 1, z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> s21 :|: s21 >= 0, s21 <= z + (1 + z1 + z2) + 1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + s23 :|: s23 >= 0, s23 <= z1 + z2 + 1, z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + s22 :|: s22 >= 0, s22 <= z' + z2 + 1, z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {len}, {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  len: runtime: ?, size: O(n^1) [z]

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

(77) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 4 + z1' + z2' }-> 1 + BSORT(z - 1, s17) + s8 :|: s17 >= 0, s17 <= z1 + (1 + z1' + z2') + 1, s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 3 + z2 }-> 1 + BSORT(z - 1, 0) + s10 :|: s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 3 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + s9 :|: s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(plus(1 + 0, len(z11)), 1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 1 + (z - 1) + (1 + (1 + z12) + z2) + 1, s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s19 :|: s19 >= 0, s19 <= 0 + (1 + (1 + z03) + z2) + 1, z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z + (1 + 0 + (z' - 1)) + 1, z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> s21 :|: s21 >= 0, s21 <= z + (1 + z1 + z2) + 1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + s23 :|: s23 >= 0, s23 <= z1 + z2 + 1, z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + s22 :|: s22 >= 0, s22 <= z' + z2 + 1, z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> plus(1 + 0, plus(1 + 0, len(z13))) :|: z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  len: runtime: O(1) [0], size: O(n^1) [z]

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 4 + z1' + z2' }-> 1 + BSORT(z - 1, s17) + s8 :|: s17 >= 0, s17 <= z1 + (1 + z1' + z2') + 1, s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 3 + z2 }-> 1 + BSORT(z - 1, 0) + s10 :|: s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 3 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + s9 :|: s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(s25, 1 + z01 + z11) :|: s24 >= 0, s24 <= z11, s25 >= 0, s25 <= 1 + 0 + s24, z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 1 + (z - 1) + (1 + (1 + z12) + z2) + 1, s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s19 :|: s19 >= 0, s19 <= 0 + (1 + (1 + z03) + z2) + 1, z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z + (1 + 0 + (z' - 1)) + 1, z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> s21 :|: s21 >= 0, s21 <= z + (1 + z1 + z2) + 1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + s23 :|: s23 >= 0, s23 <= z1 + z2 + 1, z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + s22 :|: s22 >= 0, s22 <= z' + z2 + 1, z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> s28 :|: s26 >= 0, s26 <= z13, s27 >= 0, s27 <= 1 + 0 + s26, s28 >= 0, s28 <= 1 + 0 + s27, z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  len: runtime: O(1) [0], size: O(n^1) [z]

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

(81) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 4 + z1' + z2' }-> 1 + BSORT(z - 1, s17) + s8 :|: s17 >= 0, s17 <= z1 + (1 + z1' + z2') + 1, s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 3 + z2 }-> 1 + BSORT(z - 1, 0) + s10 :|: s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 3 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + s9 :|: s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(s25, 1 + z01 + z11) :|: s24 >= 0, s24 <= z11, s25 >= 0, s25 <= 1 + 0 + s24, z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 1 + (z - 1) + (1 + (1 + z12) + z2) + 1, s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s19 :|: s19 >= 0, s19 <= 0 + (1 + (1 + z03) + z2) + 1, z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z + (1 + 0 + (z' - 1)) + 1, z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> s21 :|: s21 >= 0, s21 <= z + (1 + z1 + z2) + 1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + s23 :|: s23 >= 0, s23 <= z1 + z2 + 1, z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + s22 :|: s22 >= 0, s22 <= z' + z2 + 1, z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> s28 :|: s26 >= 0, s26 <= z13, s27 >= 0, s27 <= 1 + 0 + s26, s28 >= 0, s28 <= 1 + 0 + s27, z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {BSORT}, {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  len: runtime: O(1) [0], size: O(n^1) [z]
  BSORT: runtime: ?, size: O(1) [0]

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

(83) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: BSORT
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 10*z + 3*z*z'

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ 4 + z1' + z2' }-> 1 + BSORT(z - 1, s17) + s8 :|: s17 >= 0, s17 <= z1 + (1 + z1' + z2') + 1, s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ 3 + z2 }-> 1 + BSORT(z - 1, 0) + s10 :|: s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BSORT(z, z') -{ 3 }-> 1 + BSORT(z - 1, 1 + (z' - 1) + 0) + s9 :|: s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(s25, 1 + z01 + z11) :|: s24 >= 0, s24 <= z11, s25 >= 0, s25 <= 1 + 0 + s24, z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, z) :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + BSORT(0, 0) :|: z = 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 1 + (z - 1) + (1 + (1 + z12) + z2) + 1, s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s19 :|: s19 >= 0, s19 <= 0 + (1 + (1 + z03) + z2) + 1, z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z + (1 + 0 + (z' - 1)) + 1, z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> s21 :|: s21 >= 0, s21 <= z + (1 + z1 + z2) + 1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + s23 :|: s23 >= 0, s23 <= z1 + z2 + 1, z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + s22 :|: s22 >= 0, s22 <= z' + z2 + 1, z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> s28 :|: s26 >= 0, s26 <= z13, s27 >= 0, s27 <= 1 + 0 + s26, s28 >= 0, s28 <= 1 + 0 + s27, z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  len: runtime: O(1) [0], size: O(n^1) [z]
  BSORT: runtime: O(n^2) [10*z + 3*z*z'], size: O(1) [0]

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ -6 + -3*s17 + 3*s17*z + 10*z + z1' + z2' }-> 1 + s29 + s8 :|: s29 >= 0, s29 <= 0, s17 >= 0, s17 <= z1 + (1 + z1' + z2') + 1, s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ -7 + 10*z + 3*z*z' + -3*z' }-> 1 + s30 + s9 :|: s30 >= 0, s30 <= 0, s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ -7 + 10*z + z2 }-> 1 + s31 + s10 :|: s31 >= 0, s31 <= 0, s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + s32 :|: s32 >= 0, s32 <= 0, z = 0
   BUBBLESORT(z) -{ 0 }-> 1 + s33 :|: s33 >= 0, s33 <= 0, z >= 0
   BUBBLESORT(z) -{ 13*s25 + 3*s25*z01 + 3*s25*z11 }-> 1 + s34 :|: s34 >= 0, s34 <= 0, s24 >= 0, s24 <= z11, s25 >= 0, s25 <= 1 + 0 + s24, z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 1 + (z - 1) + (1 + (1 + z12) + z2) + 1, s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s19 :|: s19 >= 0, s19 <= 0 + (1 + (1 + z03) + z2) + 1, z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z + (1 + 0 + (z' - 1)) + 1, z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> s21 :|: s21 >= 0, s21 <= z + (1 + z1 + z2) + 1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + s23 :|: s23 >= 0, s23 <= z1 + z2 + 1, z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + s22 :|: s22 >= 0, s22 <= z' + z2 + 1, z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> s28 :|: s26 >= 0, s26 <= z13, s27 >= 0, s27 <= 1 + 0 + s26, s28 >= 0, s28 <= 1 + 0 + s27, z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  len: runtime: O(1) [0], size: O(n^1) [z]
  BSORT: runtime: O(n^2) [10*z + 3*z*z'], size: O(1) [0]

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

(87) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ -6 + -3*s17 + 3*s17*z + 10*z + z1' + z2' }-> 1 + s29 + s8 :|: s29 >= 0, s29 <= 0, s17 >= 0, s17 <= z1 + (1 + z1' + z2') + 1, s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ -7 + 10*z + 3*z*z' + -3*z' }-> 1 + s30 + s9 :|: s30 >= 0, s30 <= 0, s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ -7 + 10*z + z2 }-> 1 + s31 + s10 :|: s31 >= 0, s31 <= 0, s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + s32 :|: s32 >= 0, s32 <= 0, z = 0
   BUBBLESORT(z) -{ 0 }-> 1 + s33 :|: s33 >= 0, s33 <= 0, z >= 0
   BUBBLESORT(z) -{ 13*s25 + 3*s25*z01 + 3*s25*z11 }-> 1 + s34 :|: s34 >= 0, s34 <= 0, s24 >= 0, s24 <= z11, s25 >= 0, s25 <= 1 + 0 + s24, z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 1 + (z - 1) + (1 + (1 + z12) + z2) + 1, s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s19 :|: s19 >= 0, s19 <= 0 + (1 + (1 + z03) + z2) + 1, z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z + (1 + 0 + (z' - 1)) + 1, z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> s21 :|: s21 >= 0, s21 <= z + (1 + z1 + z2) + 1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + s23 :|: s23 >= 0, s23 <= z1 + z2 + 1, z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + s22 :|: s22 >= 0, s22 <= z' + z2 + 1, z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> s28 :|: s26 >= 0, s26 <= z13, s27 >= 0, s27 <= 1 + 0 + s26, s28 >= 0, s28 <= 1 + 0 + s27, z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: {BUBBLESORT}
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  len: runtime: O(1) [0], size: O(n^1) [z]
  BSORT: runtime: O(n^2) [10*z + 3*z*z'], size: O(1) [0]
  BUBBLESORT: runtime: ?, size: O(1) [1]

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

(89) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: BUBBLESORT
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 13 + 19*z + 6*z^2

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

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

   <'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   <'(z, z') -{ 0 }-> 1 + s2 :|: s2 >= 0, s2 <= z' - 1, z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ -6 + -3*s17 + 3*s17*z + 10*z + z1' + z2' }-> 1 + s29 + s8 :|: s29 >= 0, s29 <= 0, s17 >= 0, s17 <= z1 + (1 + z1' + z2') + 1, s8 >= 0, s8 <= 3 * (1 + z1' + z2') + 8 * ((1 + z1' + z2') * (1 + z1' + z2')), s4 >= 0, s4 <= 2, z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 1 >= 0
   BSORT(z, z') -{ -7 + 10*z + 3*z*z' + -3*z' }-> 1 + s30 + s9 :|: s30 >= 0, s30 <= 0, s9 >= 0, s9 <= 3 * 0 + 8 * (0 * 0), z' - 1 >= 0, z - 1 >= 0
   BSORT(z, z') -{ -7 + 10*z + z2 }-> 1 + s31 + s10 :|: s31 >= 0, s31 <= 0, s10 >= 0, s10 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z' = 1 + z1 + z2, z - 1 >= 0, z2 >= 0
   BUBBLE(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   BUBBLE(z, z') -{ 4 + z1'' + z2 }-> 1 + s11 + s :|: s11 >= 0, s11 <= 6 * (1 + (1 + z1'') + z2) + 16 * ((1 + (1 + z1'') + z2) * (1 + (1 + z1'') + z2)) + 2, s5 >= 0, s5 <= 2, s >= 0, s <= 1 + z1'', z' = 1 + (1 + z1'') + z2, z - 1 >= 0, z2 >= 0, z1'' >= 0
   BUBBLE(z, z') -{ 4 + z0'' + z2 }-> 1 + s12 + s' :|: s12 >= 0, s12 <= 6 * (1 + (1 + z0'') + z2) + 16 * ((1 + (1 + z0'') + z2) * (1 + (1 + z0'') + z2)) + 2, s' >= 0, s' <= 1 + z0'', z' = 1 + (1 + z0'') + z2, z0'' >= 0, z = 0, z2 >= 0
   BUBBLE(z, z') -{ 2 + z' }-> 1 + s13 + s'' :|: s13 >= 0, s13 <= 6 * (1 + 0 + (z' - 1)) + 16 * ((1 + 0 + (z' - 1)) * (1 + 0 + (z' - 1))) + 2, s'' >= 0, s'' <= 0, z >= 0, z' - 1 >= 0
   BUBBLE(z, z') -{ 3 + z1 + z2 }-> 1 + s14 + s1 :|: s14 >= 0, s14 <= 6 * (1 + z1 + z2) + 16 * ((1 + z1 + z2) * (1 + z1 + z2)) + 2, s1 >= 0, s1 <= z1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   BUBBLESORT(z) -{ 0 }-> 0 :|: z >= 0
   BUBBLESORT(z) -{ 0 }-> 1 + s32 :|: s32 >= 0, s32 <= 0, z = 0
   BUBBLESORT(z) -{ 0 }-> 1 + s33 :|: s33 >= 0, s33 <= 0, z >= 0
   BUBBLESORT(z) -{ 13*s25 + 3*s25*z01 + 3*s25*z11 }-> 1 + s34 :|: s34 >= 0, s34 <= 0, s24 >= 0, s24 <= z11, s25 >= 0, s25 <= 1 + 0 + s24, z11 >= 0, z01 >= 0, z = 1 + z01 + z11
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s15 :|: s15 >= 0, s15 <= 3 * z2 + 8 * (z2 * z2), z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   BUBBLE[ITE][FALSE][ITE](z, z', z'') -{ 2 + z2 }-> 1 + s16 :|: s16 >= 0, s16 <= 3 * z2 + 8 * (z2 * z2), z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   LEN(z) -{ 1 + z1 }-> 1 + s3 :|: s3 >= 0, s3 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   bubble(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 1 + (z - 1) + (1 + (1 + z12) + z2) + 1, s6 >= 0, s6 <= 2, z' = 1 + (1 + z12) + z2, z - 1 >= 0, z12 >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s19 :|: s19 >= 0, s19 <= 0 + (1 + (1 + z03) + z2) + 1, z' = 1 + (1 + z03) + z2, z03 >= 0, z = 0, z2 >= 0
   bubble(z, z') -{ 0 }-> s20 :|: s20 >= 0, s20 <= z + (1 + 0 + (z' - 1)) + 1, z >= 0, z' - 1 >= 0
   bubble(z, z') -{ 0 }-> s21 :|: s21 >= 0, s21 <= z + (1 + z1 + z2) + 1, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   bubble(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   bubble(z, z') -{ 0 }-> 1 + z + 0 :|: z >= 0, z' = 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z' + s23 :|: s23 >= 0, s23 <= z1 + z2 + 1, z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   bubble[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + z1 + s22 :|: s22 >= 0, s22 <= z' + z2 + 1, z1 >= 0, z = 1, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   len(z) -{ 0 }-> s28 :|: s26 >= 0, s26 <= z13, s27 >= 0, s27 <= 1 + 0 + s26, s28 >= 0, s28 <= 1 + 0 + s27, z04 >= 0, z = 1 + z0 + (1 + z04 + z13), z0 >= 0, z13 >= 0
   len(z) -{ 0 }-> 0 :|: z = 0
   len(z) -{ 0 }-> 0 :|: z >= 0
   len(z) -{ 0 }-> 0 :|: z - 1 >= 0, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, v0 >= 0, v1 >= 0, 1 + 0 = v0, 0 = v1
   len(z) -{ 0 }-> 1 + z0' :|: z - 1 >= 0, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   len(z) -{ 0 }-> 1 + z0' :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, 1 + 0 = 1 + 0, z0' >= 0, 0 = z0'
   lt(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + z :|: z' = 1 + 0, z >= 0
   plus(z, z') -{ 0 }-> 1 + z' :|: z = 1 + 0, z' >= 0

Function symbols to be analyzed: 
Previous analysis results are:
  <': runtime: O(1) [0], size: O(n^1) [z']
  LEN: runtime: O(n^1) [z], size: O(1) [0]
  lt: runtime: O(1) [0], size: O(1) [2]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  BUBBLE: runtime: O(n^1) [2 + z'], size: O(n^2) [3*z' + 8*z'^2]
  BUBBLE[ITE][FALSE][ITE]: runtime: O(n^1) [1 + z''], size: O(n^2) [2 + 6*z'' + 16*z''^2]
  bubble[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [1 + z' + z'']
  bubble: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  len: runtime: O(1) [0], size: O(n^1) [z]
  BSORT: runtime: O(n^2) [10*z + 3*z*z'], size: O(1) [0]
  BUBBLESORT: runtime: O(n^2) [13 + 19*z + 6*z^2], size: O(1) [1]

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

(91) FinalProof (FINISHED)
Computed overall runtime complexity
----------------------------------------

(92)
BOUNDS(1, n^2)