tct
MAYBE
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We add following dependency tuples
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, append#1^#(nil(), @l2) -> c_3()
, append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, append3#1^#(nil(), @l2) -> c_6()
, append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, append4#1^#(nil(), @l2) -> c_9()
, attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, attach#1^#(nil(), @n) -> c_12()
, attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, attach3#1^#(nil(), @n) -> c_15()
, attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, attach4#1^#(nil(), @n) -> c_18()
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, pairs#1^#(nil()) -> c_21()
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, pairs'#1^#(nil()) -> c_24()
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, pairs_aux#1^#(nil(), @acc) -> c_27()
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, quadruples#1^#(nil()) -> c_30()
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
, triples#1^#(nil()) -> c_33() }
and replace the set of basic marked basic terms accordingly.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, append#1^#(nil(), @l2) -> c_3()
, append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, append3#1^#(nil(), @l2) -> c_6()
, append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, append4#1^#(nil(), @l2) -> c_9()
, attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, attach#1^#(nil(), @n) -> c_12()
, attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, attach3#1^#(nil(), @n) -> c_15()
, attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, attach4#1^#(nil(), @n) -> c_18()
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, pairs#1^#(nil()) -> c_21()
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, pairs'#1^#(nil()) -> c_24()
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, pairs_aux#1^#(nil(), @acc) -> c_27()
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, quadruples#1^#(nil()) -> c_30()
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
, triples#1^#(nil()) -> c_33() }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
-->_1 append#1^#(nil(), @l2) -> c_3() :3
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: append#1^#(nil(), @l2) -> c_3()
4: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :5
-->_1 append3#1^#(nil(), @l2) -> c_6() :6
5: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :4
6: append3#1^#(nil(), @l2) -> c_6()
7: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
-->_1 append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) :8
-->_1 append4#1^#(nil(), @l2) -> c_9() :9
8: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :7
9: append4#1^#(nil(), @l2) -> c_9()
10: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :11
-->_1 attach#1^#(nil(), @n) -> c_12() :12
11: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :10
12: attach#1^#(nil(), @n) -> c_12()
13: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :14
-->_1 attach3#1^#(nil(), @n) -> c_15() :15
14: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :13
15: attach3#1^#(nil(), @n) -> c_15()
16: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
-->_1 attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) :17
-->_1 attach4#1^#(nil(), @n) -> c_18() :18
17: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
-->_1 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :16
18: attach4#1^#(nil(), @n) -> c_18()
19: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :20
-->_1 pairs#1^#(nil()) -> c_21() :21
20: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :19
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :10
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
21: pairs#1^#(nil()) -> c_21()
22: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :23
-->_1 pairs'#1^#(nil()) -> c_24() :24
23: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :22
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :10
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
24: pairs'#1^#(nil()) -> c_24()
25: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :26
-->_1 pairs_aux#1^#(nil(), @acc) -> c_27() :27
26: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :25
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :10
-->_2 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
27: pairs_aux#1^#(nil(), @acc) -> c_27()
28: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :29
-->_1 quadruples#1^#(nil()) -> c_30() :30
29: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :31
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :28
-->_2 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :16
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :7
30: quadruples#1^#(nil()) -> c_30()
31: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :32
-->_1 triples#1^#(nil()) -> c_33() :33
32: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :31
-->_3 pairs^#(@l) -> pairs#1^#(@l) :19
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :13
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :4
33: triples#1^#(nil()) -> c_33()
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {30} and add Pre({30}) = {28} to the strict component.
- We remove {33} and add Pre({33}) = {31} to the strict component.
- We remove {27} and add Pre({27}) = {25} to the strict component.
- We remove {24} and add Pre({24}) = {22} to the strict component.
- We remove {21} and add Pre({21}) = {19} to the strict component.
- We remove {18} and add Pre({18}) = {16} to the strict component.
- We remove {15} and add Pre({15}) = {13} to the strict component.
- We remove {12} and add Pre({12}) = {10} to the strict component.
- We remove {9} and add Pre({9}) = {7} to the strict component.
- We remove {6} and add Pre({6}) = {4} to the strict component.
- We remove {3} and add Pre({3}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs:
{ append#1^#(nil(), @l2) -> c_3()
, append3#1^#(nil(), @l2) -> c_6()
, append4#1^#(nil(), @l2) -> c_9()
, attach#1^#(nil(), @n) -> c_12()
, attach3#1^#(nil(), @n) -> c_15()
, attach4#1^#(nil(), @n) -> c_18()
, pairs#1^#(nil()) -> c_21()
, pairs'#1^#(nil()) -> c_24()
, pairs_aux#1^#(nil(), @acc) -> c_27()
, quadruples#1^#(nil()) -> c_30()
, triples#1^#(nil()) -> c_33() }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the the dependency graph
->7:{15,16}
|
|->21:{1,2}
| |
| `->22:{23} Weak SCC
|
|->15:{7,8}
| |
| `->16:{26} Weak SCC
|
`->8:{30} Weak SCC
->5:{17,18}
|
|->21:{1,2}
| |
| `->22:{23} Weak SCC
|
|->15:{7,8}
| |
| `->16:{26} Weak SCC
|
`->6:{31} Weak SCC
->1:{19,20}
|
|->17:{5,6}
| |
| `->18:{25} Weak SCC
|
|->11:{11,12}
| |
| `->12:{28} Weak SCC
|
|->3:{21,22}
| |
| |->19:{3,4}
| | |
| | `->20:{24} Weak SCC
| |
| |->13:{9,10}
| | |
| | `->14:{27} Weak SCC
| |
| |->9:{13,14}
| | |
| | |->21:{1,2}
| | | |
| | | `->22:{23} Weak SCC
| | |
| | |->15:{7,8}
| | | |
| | | `->16:{26} Weak SCC
| | |
| | `->10:{29} Weak SCC
| |
| `->4:{33} Weak SCC
|
`->2:{32} Weak SCC
Here dependency-pairs are as follows:
Strict DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, 4: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, 5: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, 6: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, 7: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 8: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 9: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, 10: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, 11: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, 12: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, 13: pairs^#(@l) -> pairs#1^#(@l)
, 14: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, 15: pairs'^#(@l) -> pairs'#1^#(@l)
, 16: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, 17: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 18: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, 19: quadruples^#(@l) -> quadruples#1^#(@l)
, 20: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, 21: triples^#(@l) -> triples#1^#(@l)
, 22: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs:
{ 23: append#1^#(nil(), @l2) -> c_3()
, 24: append3#1^#(nil(), @l2) -> c_6()
, 25: append4#1^#(nil(), @l2) -> c_9()
, 26: attach#1^#(nil(), @n) -> c_12()
, 27: attach3#1^#(nil(), @n) -> c_15()
, 28: attach4#1^#(nil(), @n) -> c_18()
, 29: pairs#1^#(nil()) -> c_21()
, 30: pairs'#1^#(nil()) -> c_24()
, 31: pairs_aux#1^#(nil(), @acc) -> c_27()
, 32: quadruples#1^#(nil()) -> c_30()
, 33: triples#1^#(nil()) -> c_33() }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 32: quadruples#1^#(nil()) -> c_30()
, 33: triples#1^#(nil()) -> c_33()
, 31: pairs_aux#1^#(nil(), @acc) -> c_27()
, 30: pairs'#1^#(nil()) -> c_24()
, 29: pairs#1^#(nil()) -> c_21()
, 28: attach4#1^#(nil(), @n) -> c_18()
, 27: attach3#1^#(nil(), @n) -> c_15()
, 26: attach#1^#(nil(), @n) -> c_12()
, 25: append4#1^#(nil(), @l2) -> c_9()
, 24: append3#1^#(nil(), @l2) -> c_6()
, 23: append#1^#(nil(), @l2) -> c_3() }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We employ 'linear path analysis' using the following approximated
dependency graph:
->4:{15,16} [ ? ]
|
|->11:{1,2} [ YES(O(1),O(n^3)) ]
|
`->8:{7,8} [ YES(O(1),O(n^2)) ]
->3:{17,18} [ ? ]
|
|->11:{1,2} [ YES(O(1),O(n^2)) ]
|
`->8:{7,8} [ YES(O(1),O(n^2)) ]
->1:{19,20} [ ? ]
|
|->9:{5,6} [ MAYBE ]
|
|->6:{11,12} [ MAYBE ]
|
`->2:{21,22} [ ? ]
|
|->10:{3,4} [ MAYBE ]
|
|->7:{9,10} [ MAYBE ]
|
`->5:{13,14} [ ? ]
|
|->11:{1,2} [ MAYBE ]
|
`->8:{7,8} [ MAYBE ]
Here dependency-pairs are as follows:
Strict DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, 4: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, 5: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, 6: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, 7: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 8: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 9: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, 10: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, 11: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, 12: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, 13: pairs^#(@l) -> pairs#1^#(@l)
, 14: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, 15: pairs'^#(@l) -> pairs'#1^#(@l)
, 16: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, 17: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 18: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, 19: quadruples^#(@l) -> quadruples#1^#(@l)
, 20: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, 21: triples^#(@l) -> triples#1^#(@l)
, 22: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
* Path 4:{15,16}->11:{1,2}: YES(O(1),O(n^3))
------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :4
4: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :3
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak DPs: { append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :4
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :3
3: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the following dependency-graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :3
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :4
3: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
Remaining Rules (B):
{ pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { append^#(@l1, @l2) -> append#1^#(@l1, @l2) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) -> append^#(pairs'(@xs), attach(@x, @xs))
, pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) YES(O(1),O(n^1)).
Sub-proof:
----------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) :2
2: pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) :2
2: pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs: { pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
No rule is usable.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs: { pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'Small Polynomial Path Order (PS,1-bounded)'
to orient following rules strictly.
DPs:
{ 2: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,1-bounded)' as induced by the safe mapping
safe(append) = {}, safe(append#1) = {}, safe(::) = {1, 2},
safe(nil) = {}, safe(attach) = {}, safe(attach#1) = {},
safe(tuple#2) = {1, 2}, safe(pairs') = {}, safe(pairs'#1) = {},
safe(append^#) = {}, safe(append#1^#) = {}, safe(append3^#) = {},
safe(append3#1^#) = {}, safe(append4^#) = {},
safe(append4#1^#) = {}, safe(attach^#) = {}, safe(attach#1^#) = {},
safe(attach3^#) = {}, safe(attach3#1^#) = {}, safe(attach4^#) = {},
safe(attach4#1^#) = {}, safe(pairs^#) = {}, safe(pairs#1^#) = {},
safe(pairs'^#) = {}, safe(pairs'#1^#) = {}, safe(pairs_aux^#) = {},
safe(pairs_aux#1^#) = {}, safe(quadruples^#) = {},
safe(quadruples#1^#) = {}, safe(triples^#) = {},
safe(triples#1^#) = {}, safe(c_1) = {}, safe(c) = {}
and precedence
pairs'^# ~ pairs'#1^# .
Following symbols are considered recursive:
{}
The recursion depth is 0.
Further, following argument filtering is employed:
pi(append) = [], pi(append#1) = [], pi(::) = [2], pi(nil) = [],
pi(attach) = [], pi(attach#1) = [], pi(tuple#2) = [],
pi(pairs') = [], pi(pairs'#1) = [], pi(append^#) = [],
pi(append#1^#) = [], pi(append3^#) = [], pi(append3#1^#) = [],
pi(append4^#) = [], pi(append4#1^#) = [], pi(attach^#) = [],
pi(attach#1^#) = [], pi(attach3^#) = [], pi(attach3#1^#) = [],
pi(attach4^#) = [], pi(attach4#1^#) = [], pi(pairs^#) = [],
pi(pairs#1^#) = [], pi(pairs'^#) = 1, pi(pairs'#1^#) = 1,
pi(pairs_aux^#) = [], pi(pairs_aux#1^#) = [],
pi(quadruples^#) = [], pi(quadruples#1^#) = [], pi(triples^#) = [],
pi(triples#1^#) = [], pi(c_1) = [], pi(c) = []
Usable defined function symbols are a subset of:
{}
For your convenience, here are the satisfied ordering constraints:
pi(pairs'^#(@l)) = @l
>= @l
= pi(pairs'#1^#(@l))
pi(pairs'#1^#(::(@x, @xs))) = ::(; @xs)
> @xs
= pi(pairs'^#(@xs))
Processor 'Small Polynomial Path Order (PS,1-bounded)' induces the
complexity certificate YES(?,O(n^1)) on application of rules {2}.
Here rules are labeled according to the (estimated) dependency
graph
1: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) :2
2: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs)
-->_1 pairs'^#(@l) -> pairs'#1^#(@l) :1
- The rules {2} have known complexity. These cover all predecessors
of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules {1,2}
is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: pairs'^#(@l) -> pairs'#1^#(@l)
, 2: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 1: pairs'^#(@l) -> pairs'#1^#(@l)
, 2: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
We apply the transformation 'usablerules' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs: { append^#(@l1, @l2) -> append#1^#(@l1, @l2) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) -> append^#(pairs'(@xs), attach(@x, @xs))
, pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We use the processor 'custom shape polynomial interpretation' to
orient following rules strictly.
DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 4: pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs))
, 5: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Trs:
{ attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs)) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(append) = {}, Uargs(append#1) = {}, Uargs(::) = {},
Uargs(attach) = {}, Uargs(attach#1) = {}, Uargs(tuple#2) = {},
Uargs(pairs') = {}, Uargs(pairs'#1) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(append3^#) = {},
Uargs(append3#1^#) = {}, Uargs(append4^#) = {},
Uargs(append4#1^#) = {}, Uargs(attach^#) = {},
Uargs(attach#1^#) = {}, Uargs(attach3^#) = {},
Uargs(attach3#1^#) = {}, Uargs(attach4^#) = {},
Uargs(attach4#1^#) = {}, Uargs(pairs^#) = {},
Uargs(pairs#1^#) = {}, Uargs(pairs'^#) = {},
Uargs(pairs'#1^#) = {}, Uargs(pairs_aux^#) = {},
Uargs(pairs_aux#1^#) = {}, Uargs(quadruples^#) = {},
Uargs(quadruples#1^#) = {}, Uargs(triples^#) = {},
Uargs(triples#1^#) = {}
TcT has computed following constructor-restricted polynomial
interpretation.
[append](x1, x2) = x1 + 2*x2
[append#1](x1, x2) = x1 + 2*x2
[::](x1, x2) = 3 + x2
[nil]() = 0
[attach](x1, x2) = 2 + 3*x2
[attach#1](x1, x2) = 3*x1
[tuple#2](x1, x2) = 0
[pairs'](x1) = x1^2
[pairs'#1](x1) = x1^2
[append^#](x1, x2) = 1 + 2*x1
[append#1^#](x1, x2) = 2*x1
[append3^#](x1, x2) = 0
[append3#1^#](x1, x2) = 0
[append4^#](x1, x2) = 0
[append4#1^#](x1, x2) = 0
[attach^#](x1, x2) = 0
[attach#1^#](x1, x2) = 0
[attach3^#](x1, x2) = 0
[attach3#1^#](x1, x2) = 0
[attach4^#](x1, x2) = 0
[attach4#1^#](x1, x2) = 0
[pairs^#](x1) = 0
[pairs#1^#](x1) = 0
[pairs'^#](x1) = 1 + 2*x1^2
[pairs'#1^#](x1) = 2*x1^2
[pairs_aux^#](x1, x2) = 0
[pairs_aux#1^#](x1, x2) = 0
[quadruples^#](x1) = 0
[quadruples#1^#](x1) = 0
[triples^#](x1) = 0
[triples#1^#](x1) = 0
This order satisfies following ordering constraints
[append(@l1, @l2)] = @l1 + 2*@l2
>= @l1 + 2*@l2
= [append#1(@l1, @l2)]
[append#1(::(@x, @xs), @l2)] = 3 + @xs + 2*@l2
>= 3 + @xs + 2*@l2
= [::(@x, append(@xs, @l2))]
[append#1(nil(), @l2)] = 2*@l2
>= @l2
= [@l2]
[attach(@n, @l)] = 2 + 3*@l
> 3*@l
= [attach#1(@l, @n)]
[attach#1(::(@x, @xs), @n)] = 9 + 3*@xs
> 5 + 3*@xs
= [::(tuple#2(@n, @x), attach(@n, @xs))]
[attach#1(nil(), @n)] =
>=
= [nil()]
[pairs'(@l)] = @l^2
>= @l^2
= [pairs'#1(@l)]
[pairs'#1(::(@x, @xs))] = 9 + 6*@xs + @xs^2
> @xs^2 + 4 + 6*@xs
= [append(pairs'(@xs), attach(@x, @xs))]
[pairs'#1(nil())] =
>=
= [nil()]
[append^#(@l1, @l2)] = 1 + 2*@l1
> 2*@l1
= [append#1^#(@l1, @l2)]
[append#1^#(::(@x, @xs), @l2)] = 6 + 2*@xs
> 1 + 2*@xs
= [append^#(@xs, @l2)]
[pairs'^#(@l)] = 1 + 2*@l^2
> 2*@l^2
= [pairs'#1^#(@l)]
[pairs'#1^#(::(@x, @xs))] = 18 + 12*@xs + 2*@xs^2
> 1 + 2*@xs^2
= [append^#(pairs'(@xs), attach(@x, @xs))]
[pairs'#1^#(::(@x, @xs))] = 18 + 12*@xs + 2*@xs^2
> 1 + 2*@xs^2
= [pairs'^#(@xs)]
Processor 'custom shape polynomial interpretation' induces the
complexity certificate YES(?,O(n^2)) on application of rules
{1,2,3,4,5}. Here rules are labeled according to the (estimated)
dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) :5
-->_1 pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs)) :4
4: pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs))
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
5: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs)
-->_1 pairs'^#(@l) -> pairs'#1^#(@l) :3
Overall, we obtain that the number of applications of rules
{1,2,3,4,5} is given by YES(?,O(n^2)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) -> append^#(pairs'(@xs), attach(@x, @xs))
, pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{3,5} Weak SCC
|
`->2:{4} Weak SCC
|
`->3:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 4: pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs))
, 5: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 5: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs)
, 4: pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs))
, 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
* Path 4:{15,16}->8:{7,8}: YES(O(1),O(n^2))
-----------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :2
2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
3: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :4
4: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :3
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak DPs: { attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :4
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :3
3: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the following dependency-graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :3
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :4
3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
No rule is usable.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.
DPs:
{ 2: pairs'^#(@l) -> pairs'#1^#(@l)
, 3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(::) = {}, Uargs(tuple#2) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(append3^#) = {},
Uargs(append3#1^#) = {}, Uargs(append4^#) = {},
Uargs(append4#1^#) = {}, Uargs(attach^#) = {},
Uargs(attach#1^#) = {}, Uargs(attach3^#) = {},
Uargs(attach3#1^#) = {}, Uargs(attach4^#) = {},
Uargs(attach4#1^#) = {}, Uargs(pairs^#) = {},
Uargs(pairs#1^#) = {}, Uargs(pairs'^#) = {},
Uargs(pairs'#1^#) = {}, Uargs(pairs_aux^#) = {},
Uargs(pairs_aux#1^#) = {}, Uargs(quadruples^#) = {},
Uargs(quadruples#1^#) = {}, Uargs(triples^#) = {},
Uargs(triples#1^#) = {}, Uargs(c_1) = {1, 2}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[::](x1, x2) = [1 1] x2 + [1]
[0 1] [3]
[nil] = [0]
[0]
[tuple#2](x1, x2) = [0]
[0]
[append^#](x1, x2) = [0]
[0]
[append#1^#](x1, x2) = [0]
[0]
[append3^#](x1, x2) = [0]
[0]
[append3#1^#](x1, x2) = [0]
[0]
[append4^#](x1, x2) = [0]
[0]
[append4#1^#](x1, x2) = [0]
[0]
[attach^#](x1, x2) = [0 1] x2 + [0]
[1 3] [1]
[attach#1^#](x1, x2) = [0 1] x1 + [0]
[1 3] [0]
[attach3^#](x1, x2) = [0]
[0]
[attach3#1^#](x1, x2) = [0]
[0]
[attach4^#](x1, x2) = [0]
[0]
[attach4#1^#](x1, x2) = [0]
[0]
[pairs^#](x1) = [0]
[0]
[pairs#1^#](x1) = [0]
[0]
[pairs'^#](x1) = [1 0] x1 + [1]
[0 0] [1]
[pairs'#1^#](x1) = [1 0] x1 + [0]
[0 0] [0]
[pairs_aux^#](x1, x2) = [0]
[0]
[pairs_aux#1^#](x1, x2) = [0]
[0]
[quadruples^#](x1) = [0]
[0]
[quadruples#1^#](x1) = [0]
[0]
[triples^#](x1) = [0]
[0]
[triples#1^#](x1) = [0]
[0]
[c_1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 0] [0]
This order satisfies following ordering constraints
[attach^#(@n, @l)] = [0 1] @l + [0]
[1 3] [1]
>= [0 1] @l + [0]
[1 3] [0]
= [attach#1^#(@l, @n)]
[attach#1^#(::(@x, @xs), @n)] = [0 1] @xs + [3]
[1 4] [10]
> [0 1] @xs + [0]
[1 3] [1]
= [attach^#(@n, @xs)]
[pairs'^#(@l)] = [1 0] @l + [1]
[0 0] [1]
> [1 0] @l + [0]
[0 0] [0]
= [pairs'#1^#(@l)]
[pairs'#1^#(::(@x, @xs))] = [1 1] @xs + [1]
[0 0] [0]
>= [1 1] @xs + [1]
[0 0] [0]
= [c_1(pairs'^#(@xs), attach^#(@x, @xs))]
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^2)) on application of rules {2,3}.
Here rules are labeled according to the (estimated) dependency
graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :3
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) :4
3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: pairs'#1^#(::(@x, @xs)) -> c_1(pairs'^#(@xs), attach^#(@x, @xs))
-->_1 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
- The rules {2,3} have known complexity. These cover all
predecessors of {4}, their complexity is equally bounded.
- The rules {2,3,4} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4} is given by YES(?,O(n^2)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{3,4} Weak SCC
|
`->2:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 4: pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 4: pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs))
, 1: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
* Path 3:{17,18}->11:{1,2}: YES(O(1),O(n^2))
------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :4
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :3
-->_2 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak DPs: { append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :4
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :3
3: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_2 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the following dependency-graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :3
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :4
3: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_2 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
Remaining Rules (B):
{ pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { append^#(@l1, @l2) -> append#1^#(@l1, @l2) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
append^#(attach(@x, @xs), @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) YES(O(1),O(n^1)).
Sub-proof:
----------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) :2
2: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) :2
2: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'Small Polynomial Path Order (PS,1-bounded)'
to orient following rules strictly.
DPs:
{ 2: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,1-bounded)' as induced by the safe mapping
safe(append) = {1}, safe(append#1) = {}, safe(::) = {1, 2},
safe(nil) = {}, safe(attach) = {}, safe(attach#1) = {},
safe(tuple#2) = {1, 2}, safe(append^#) = {}, safe(append#1^#) = {},
safe(append3^#) = {}, safe(append3#1^#) = {}, safe(append4^#) = {},
safe(append4#1^#) = {}, safe(attach^#) = {}, safe(attach#1^#) = {},
safe(attach3^#) = {}, safe(attach3#1^#) = {}, safe(attach4^#) = {},
safe(attach4#1^#) = {}, safe(pairs^#) = {}, safe(pairs#1^#) = {},
safe(pairs'^#) = {}, safe(pairs'#1^#) = {}, safe(pairs_aux^#) = {},
safe(pairs_aux#1^#) = {}, safe(quadruples^#) = {},
safe(quadruples#1^#) = {}, safe(triples^#) = {},
safe(triples#1^#) = {}, safe(c_1) = {}, safe(c) = {}
and precedence
append > append#1, attach > attach#1 .
Following symbols are considered recursive:
{}
The recursion depth is 0.
Further, following argument filtering is employed:
pi(append) = 1, pi(append#1) = [2], pi(::) = [2], pi(nil) = [],
pi(attach) = [], pi(attach#1) = [2], pi(tuple#2) = [],
pi(append^#) = [], pi(append#1^#) = [], pi(append3^#) = [],
pi(append3#1^#) = [], pi(append4^#) = [], pi(append4#1^#) = [],
pi(attach^#) = [], pi(attach#1^#) = [], pi(attach3^#) = [],
pi(attach3#1^#) = [], pi(attach4^#) = [], pi(attach4#1^#) = [],
pi(pairs^#) = [], pi(pairs#1^#) = [], pi(pairs'^#) = [],
pi(pairs'#1^#) = [], pi(pairs_aux^#) = 1, pi(pairs_aux#1^#) = 1,
pi(quadruples^#) = [], pi(quadruples#1^#) = [], pi(triples^#) = [],
pi(triples#1^#) = [], pi(c_1) = [], pi(c) = []
Usable defined function symbols are a subset of:
{}
For your convenience, here are the satisfied ordering constraints:
pi(pairs_aux^#(@l, @acc)) = @l
>= @l
= pi(pairs_aux#1^#(@l, @acc))
pi(pairs_aux#1^#(::(@x, @xs), @acc)) = ::(; @xs)
> @xs
= pi(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)))
Processor 'Small Polynomial Path Order (PS,1-bounded)' induces the
complexity certificate YES(?,O(n^1)) on application of rules {2}.
Here rules are labeled according to the (estimated) dependency
graph
1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) :2
2: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :1
- The rules {2} have known complexity. These cover all predecessors
of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules {1,2}
is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 2: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 2: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { append^#(@l1, @l2) -> append#1^#(@l1, @l2) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
append^#(attach(@x, @xs), @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) ->
append^#(attach(@x, @xs), @acc)
, 5: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(append) = {}, Uargs(append#1) = {}, Uargs(::) = {},
Uargs(attach) = {}, Uargs(attach#1) = {}, Uargs(tuple#2) = {},
Uargs(append^#) = {}, Uargs(append#1^#) = {},
Uargs(append3^#) = {}, Uargs(append3#1^#) = {},
Uargs(append4^#) = {}, Uargs(append4#1^#) = {},
Uargs(attach^#) = {}, Uargs(attach#1^#) = {},
Uargs(attach3^#) = {}, Uargs(attach3#1^#) = {},
Uargs(attach4^#) = {}, Uargs(attach4#1^#) = {},
Uargs(pairs^#) = {}, Uargs(pairs#1^#) = {}, Uargs(pairs'^#) = {},
Uargs(pairs'#1^#) = {}, Uargs(pairs_aux^#) = {},
Uargs(pairs_aux#1^#) = {}, Uargs(quadruples^#) = {},
Uargs(quadruples#1^#) = {}, Uargs(triples^#) = {},
Uargs(triples#1^#) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[append](x1, x2) = [1] x1 + [1] x2 + [0]
[append#1](x1, x2) = [1] x1 + [1] x2 + [0]
[::](x1, x2) = [1] x1 + [1] x2 + [1]
[nil] = [0]
[attach](x1, x2) = [1] x2 + [0]
[attach#1](x1, x2) = [1] x1 + [0]
[tuple#2](x1, x2) = [0]
[append^#](x1, x2) = [1] x1 + [1]
[append#1^#](x1, x2) = [1] x1 + [0]
[append3^#](x1, x2) = [0]
[append3#1^#](x1, x2) = [0]
[append4^#](x1, x2) = [0]
[append4#1^#](x1, x2) = [0]
[attach^#](x1, x2) = [0]
[attach#1^#](x1, x2) = [0]
[attach3^#](x1, x2) = [0]
[attach3#1^#](x1, x2) = [0]
[attach4^#](x1, x2) = [0]
[attach4#1^#](x1, x2) = [0]
[pairs^#](x1) = [0]
[pairs#1^#](x1) = [0]
[pairs'^#](x1) = [0]
[pairs'#1^#](x1) = [0]
[pairs_aux^#](x1, x2) = [2] x1 + [2]
[pairs_aux#1^#](x1, x2) = [2] x1 + [2]
[quadruples^#](x1) = [0]
[quadruples#1^#](x1) = [0]
[triples^#](x1) = [0]
[triples#1^#](x1) = [0]
This order satisfies following ordering constraints
[append(@l1, @l2)] = [1] @l1 + [1] @l2 + [0]
>= [1] @l1 + [1] @l2 + [0]
= [append#1(@l1, @l2)]
[append#1(::(@x, @xs), @l2)] = [1] @l2 + [1] @x + [1] @xs + [1]
>= [1] @l2 + [1] @x + [1] @xs + [1]
= [::(@x, append(@xs, @l2))]
[append#1(nil(), @l2)] = [1] @l2 + [0]
>= [1] @l2 + [0]
= [@l2]
[attach(@n, @l)] = [1] @l + [0]
>= [1] @l + [0]
= [attach#1(@l, @n)]
[attach#1(::(@x, @xs), @n)] = [1] @x + [1] @xs + [1]
>= [1] @xs + [1]
= [::(tuple#2(@n, @x), attach(@n, @xs))]
[attach#1(nil(), @n)] = [0]
>= [0]
= [nil()]
[append^#(@l1, @l2)] = [1] @l1 + [1]
> [1] @l1 + [0]
= [append#1^#(@l1, @l2)]
[append#1^#(::(@x, @xs), @l2)] = [1] @x + [1] @xs + [1]
>= [1] @xs + [1]
= [append^#(@xs, @l2)]
[pairs_aux^#(@l, @acc)] = [2] @l + [2]
>= [2] @l + [2]
= [pairs_aux#1^#(@l, @acc)]
[pairs_aux#1^#(::(@x, @xs), @acc)] = [2] @x + [2] @xs + [4]
> [1] @xs + [1]
= [append^#(attach(@x, @xs), @acc)]
[pairs_aux#1^#(::(@x, @xs), @acc)] = [2] @x + [2] @xs + [4]
> [2] @xs + [2]
= [pairs_aux^#(@xs, append(attach(@x, @xs), @acc))]
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{1,4,5}. Here rules are labeled according to the (estimated)
dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) :5
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
append^#(attach(@x, @xs), @acc) :4
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
append^#(attach(@x, @xs), @acc)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
5: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :3
- The rules {1,4,5} have known complexity. These cover all
predecessors of {2,3}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4,5} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
append^#(attach(@x, @xs), @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{3,5} Weak SCC
|
`->2:{4} Weak SCC
|
`->3:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) ->
append^#(attach(@x, @xs), @acc)
, 5: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 5: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc))
, 4: pairs_aux#1^#(::(@x, @xs), @acc) ->
append^#(attach(@x, @xs), @acc)
, 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
* Path 3:{17,18}->8:{7,8}: YES(O(1),O(n^2))
-----------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :2
2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :4
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :3
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak DPs: { attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :4
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :3
3: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the following dependency-graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :3
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :4
3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
Remaining Rules (B):
{ pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { attach^#(@n, @l) -> attach#1^#(@l, @n) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) -> attach^#(@x, @xs)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) YES(O(1),O(n^1)).
Sub-proof:
----------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) :2
2: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) :2
2: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'Small Polynomial Path Order (PS,1-bounded)'
to orient following rules strictly.
DPs:
{ 2: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,1-bounded)' as induced by the safe mapping
safe(append) = {1}, safe(append#1) = {}, safe(::) = {1, 2},
safe(nil) = {}, safe(attach) = {}, safe(attach#1) = {},
safe(tuple#2) = {1, 2}, safe(append^#) = {}, safe(append#1^#) = {},
safe(append3^#) = {}, safe(append3#1^#) = {}, safe(append4^#) = {},
safe(append4#1^#) = {}, safe(attach^#) = {}, safe(attach#1^#) = {},
safe(attach3^#) = {}, safe(attach3#1^#) = {}, safe(attach4^#) = {},
safe(attach4#1^#) = {}, safe(pairs^#) = {}, safe(pairs#1^#) = {},
safe(pairs'^#) = {}, safe(pairs'#1^#) = {}, safe(pairs_aux^#) = {},
safe(pairs_aux#1^#) = {}, safe(quadruples^#) = {},
safe(quadruples#1^#) = {}, safe(triples^#) = {},
safe(triples#1^#) = {}, safe(c_1) = {}, safe(c) = {}
and precedence
append > append#1, attach > attach#1 .
Following symbols are considered recursive:
{}
The recursion depth is 0.
Further, following argument filtering is employed:
pi(append) = 1, pi(append#1) = [2], pi(::) = [2], pi(nil) = [],
pi(attach) = [], pi(attach#1) = [2], pi(tuple#2) = [],
pi(append^#) = [], pi(append#1^#) = [], pi(append3^#) = [],
pi(append3#1^#) = [], pi(append4^#) = [], pi(append4#1^#) = [],
pi(attach^#) = [], pi(attach#1^#) = [], pi(attach3^#) = [],
pi(attach3#1^#) = [], pi(attach4^#) = [], pi(attach4#1^#) = [],
pi(pairs^#) = [], pi(pairs#1^#) = [], pi(pairs'^#) = [],
pi(pairs'#1^#) = [], pi(pairs_aux^#) = 1, pi(pairs_aux#1^#) = 1,
pi(quadruples^#) = [], pi(quadruples#1^#) = [], pi(triples^#) = [],
pi(triples#1^#) = [], pi(c_1) = [], pi(c) = []
Usable defined function symbols are a subset of:
{}
For your convenience, here are the satisfied ordering constraints:
pi(pairs_aux^#(@l, @acc)) = @l
>= @l
= pi(pairs_aux#1^#(@l, @acc))
pi(pairs_aux#1^#(::(@x, @xs), @acc)) = ::(; @xs)
> @xs
= pi(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)))
Processor 'Small Polynomial Path Order (PS,1-bounded)' induces the
complexity certificate YES(?,O(n^1)) on application of rules {2}.
Here rules are labeled according to the (estimated) dependency
graph
1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) :2
2: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :1
- The rules {2} have known complexity. These cover all predecessors
of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules {1,2}
is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 2: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 1: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 2: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { attach^#(@n, @l) -> attach#1^#(@l, @n) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) -> attach^#(@x, @xs)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 1: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) -> attach^#(@x, @xs)
, 5: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, attach#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach(@n, @xs)) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(append) = {}, Uargs(append#1) = {}, Uargs(::) = {},
Uargs(attach) = {}, Uargs(attach#1) = {}, Uargs(tuple#2) = {},
Uargs(append^#) = {}, Uargs(append#1^#) = {},
Uargs(append3^#) = {}, Uargs(append3#1^#) = {},
Uargs(append4^#) = {}, Uargs(append4#1^#) = {},
Uargs(attach^#) = {}, Uargs(attach#1^#) = {},
Uargs(attach3^#) = {}, Uargs(attach3#1^#) = {},
Uargs(attach4^#) = {}, Uargs(attach4#1^#) = {},
Uargs(pairs^#) = {}, Uargs(pairs#1^#) = {}, Uargs(pairs'^#) = {},
Uargs(pairs'#1^#) = {}, Uargs(pairs_aux^#) = {},
Uargs(pairs_aux#1^#) = {}, Uargs(quadruples^#) = {},
Uargs(quadruples#1^#) = {}, Uargs(triples^#) = {},
Uargs(triples#1^#) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[append](x1, x2) = [2] x1 + [1] x2 + [2]
[append#1](x1, x2) = [2] x1 + [1] x2 + [0]
[::](x1, x2) = [1] x1 + [1] x2 + [2]
[nil] = [0]
[attach](x1, x2) = [2] x2 + [0]
[attach#1](x1, x2) = [2] x1 + [0]
[tuple#2](x1, x2) = [1]
[append^#](x1, x2) = [0]
[append#1^#](x1, x2) = [0]
[append3^#](x1, x2) = [0]
[append3#1^#](x1, x2) = [0]
[append4^#](x1, x2) = [0]
[append4#1^#](x1, x2) = [0]
[attach^#](x1, x2) = [2] x2 + [1]
[attach#1^#](x1, x2) = [2] x1 + [0]
[attach3^#](x1, x2) = [0]
[attach3#1^#](x1, x2) = [0]
[attach4^#](x1, x2) = [0]
[attach4#1^#](x1, x2) = [0]
[pairs^#](x1) = [0]
[pairs#1^#](x1) = [0]
[pairs'^#](x1) = [0]
[pairs'#1^#](x1) = [0]
[pairs_aux^#](x1, x2) = [3] x1 + [2]
[pairs_aux#1^#](x1, x2) = [3] x1 + [2]
[quadruples^#](x1) = [0]
[quadruples#1^#](x1) = [0]
[triples^#](x1) = [0]
[triples#1^#](x1) = [0]
This order satisfies following ordering constraints
[append(@l1, @l2)] = [2] @l1 + [1] @l2 + [2]
> [2] @l1 + [1] @l2 + [0]
= [append#1(@l1, @l2)]
[append#1(::(@x, @xs), @l2)] = [1] @l2 + [2] @x + [2] @xs + [4]
>= [1] @l2 + [1] @x + [2] @xs + [4]
= [::(@x, append(@xs, @l2))]
[append#1(nil(), @l2)] = [1] @l2 + [0]
>= [1] @l2 + [0]
= [@l2]
[attach(@n, @l)] = [2] @l + [0]
>= [2] @l + [0]
= [attach#1(@l, @n)]
[attach#1(::(@x, @xs), @n)] = [2] @x + [2] @xs + [4]
> [2] @xs + [3]
= [::(tuple#2(@n, @x), attach(@n, @xs))]
[attach#1(nil(), @n)] = [0]
>= [0]
= [nil()]
[attach^#(@n, @l)] = [2] @l + [1]
> [2] @l + [0]
= [attach#1^#(@l, @n)]
[attach#1^#(::(@x, @xs), @n)] = [2] @x + [2] @xs + [4]
> [2] @xs + [1]
= [attach^#(@n, @xs)]
[pairs_aux^#(@l, @acc)] = [3] @l + [2]
>= [3] @l + [2]
= [pairs_aux#1^#(@l, @acc)]
[pairs_aux#1^#(::(@x, @xs), @acc)] = [3] @x + [3] @xs + [8]
> [2] @xs + [1]
= [attach^#(@x, @xs)]
[pairs_aux#1^#(::(@x, @xs), @acc)] = [3] @x + [3] @xs + [8]
> [3] @xs + [2]
= [pairs_aux^#(@xs, append(attach(@x, @xs), @acc))]
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{1,2,4,5}. Here rules are labeled according to the (estimated)
dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :2
2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) :5
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) -> attach^#(@x, @xs) :4
4: pairs_aux#1^#(::(@x, @xs), @acc) -> attach^#(@x, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
5: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :3
- The rules {1,2,4,5} have known complexity. These cover all
predecessors of {3}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4,5} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) -> attach^#(@x, @xs)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{3,5} Weak SCC
|
`->2:{4} Weak SCC
|
`->3:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) -> attach^#(@x, @xs)
, 5: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 5: pairs_aux#1^#(::(@x, @xs), @acc) ->
pairs_aux^#(@xs, append(attach(@x, @xs), @acc))
, 4: pairs_aux#1^#(::(@x, @xs), @acc) -> attach^#(@x, @xs)
, 1: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
* Path 1:{19,20}->9:{5,6}: MAYBE
------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
-->_1 append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) :2
2: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak DPs: { append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
-->_1 append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) :4
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
4: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
-->_1 append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) :3
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
3: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
No subproblems were checked.
* Path 1:{19,20}->6:{11,12}: MAYBE
--------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
-->_1 attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) :2
2: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
-->_1 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
-->_2 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak DPs: { attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
-->_1 attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) :4
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
-->_2 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
4: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
-->_1 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
-->_1 attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) :3
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
3: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
-->_1 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
-->_2 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
None of the processors succeeded.
Details of failed attempt(s):
-----------------------------
1) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
2) 'With Problem ...' failed due to the following reason:
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) }
Remaining Rules (B):
{ quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { attach4^#(@n, @l) -> attach4#1^#(@l, @n) }
Weak DPs:
{ attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) -> attach4^#(@x, triples(@xs))
, quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) YES(O(1),O(n^1)).
Sub-proof:
----------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) :2
2: quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs))
-->_2 quadruples^#(@l) -> quadruples#1^#(@l) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) :2
2: quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs))
-->_2 quadruples^#(@l) -> quadruples#1^#(@l) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs: { quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
No rule is usable.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs: { quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'Small Polynomial Path Order (PS,1-bounded)'
to orient following rules strictly.
DPs:
{ 2: quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,1-bounded)' as induced by the safe mapping
safe(append) = {}, safe(append#1) = {}, safe(::) = {1, 2},
safe(nil) = {}, safe(append3) = {}, safe(append3#1) = {},
safe(attach) = {}, safe(attach#1) = {}, safe(tuple#2) = {1, 2},
safe(attach3) = {}, safe(attach3#1) = {}, safe(pairs) = {},
safe(pairs#1) = {}, safe(triples) = {}, safe(triples#1) = {},
safe(append^#) = {}, safe(append#1^#) = {}, safe(append3^#) = {},
safe(append3#1^#) = {}, safe(append4^#) = {},
safe(append4#1^#) = {}, safe(attach^#) = {}, safe(attach#1^#) = {},
safe(attach3^#) = {}, safe(attach3#1^#) = {}, safe(attach4^#) = {},
safe(attach4#1^#) = {}, safe(pairs^#) = {}, safe(pairs#1^#) = {},
safe(pairs'^#) = {}, safe(pairs'#1^#) = {}, safe(pairs_aux^#) = {},
safe(pairs_aux#1^#) = {}, safe(quadruples^#) = {},
safe(quadruples#1^#) = {}, safe(triples^#) = {},
safe(triples#1^#) = {}, safe(c_1) = {}, safe(c) = {}
and precedence
quadruples^# ~ quadruples#1^# .
Following symbols are considered recursive:
{}
The recursion depth is 0.
Further, following argument filtering is employed:
pi(append) = [], pi(append#1) = [], pi(::) = [2], pi(nil) = [],
pi(append3) = [], pi(append3#1) = [], pi(attach) = [],
pi(attach#1) = [], pi(tuple#2) = [], pi(attach3) = [],
pi(attach3#1) = [], pi(pairs) = [], pi(pairs#1) = [],
pi(triples) = [], pi(triples#1) = [], pi(append^#) = [],
pi(append#1^#) = [], pi(append3^#) = [], pi(append3#1^#) = [],
pi(append4^#) = [], pi(append4#1^#) = [], pi(attach^#) = [],
pi(attach#1^#) = [], pi(attach3^#) = [], pi(attach3#1^#) = [],
pi(attach4^#) = [], pi(attach4#1^#) = [], pi(pairs^#) = [],
pi(pairs#1^#) = [], pi(pairs'^#) = [], pi(pairs'#1^#) = [],
pi(pairs_aux^#) = [], pi(pairs_aux#1^#) = [], pi(quadruples^#) = 1,
pi(quadruples#1^#) = 1, pi(triples^#) = [], pi(triples#1^#) = [],
pi(c_1) = [], pi(c) = []
Usable defined function symbols are a subset of:
{}
For your convenience, here are the satisfied ordering constraints:
pi(quadruples^#(@l)) = @l
>= @l
= pi(quadruples#1^#(@l))
pi(quadruples#1^#(::(@x, @xs))) = ::(; @xs)
> @xs
= pi(quadruples^#(@xs))
Processor 'Small Polynomial Path Order (PS,1-bounded)' induces the
complexity certificate YES(?,O(n^1)) on application of rules {2}.
Here rules are labeled according to the (estimated) dependency
graph
1: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) :2
2: quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs)
-->_1 quadruples^#(@l) -> quadruples#1^#(@l) :1
- The rules {2} have known complexity. These cover all predecessors
of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules {1,2}
is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: quadruples^#(@l) -> quadruples#1^#(@l)
, 2: quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 1: quadruples^#(@l) -> quadruples#1^#(@l)
, 2: quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
We apply the transformation 'usablerules' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs: { attach4^#(@n, @l) -> attach4#1^#(@l, @n) }
Weak DPs:
{ attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) -> attach4^#(@x, triples(@xs))
, quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
None of the processors succeeded.
Details of failed attempt(s):
-----------------------------
1) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
2) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
* Path 1:{19,20}->2:{21,22}->10:{3,4}: MAYBE
------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :2
2: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs: { append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :6
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :5
5: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
6: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :5
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
5: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :4
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :5
3: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
4: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
5: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :3
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :3
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, quadruples#1^#(::(@x, @xs)) ->
c_1(triples^#(@xs), quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_2(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
No subproblems were checked.
* Path 1:{19,20}->2:{21,22}->7:{9,10}: MAYBE
------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :2
2: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs: { attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :6
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :5
5: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
6: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :5
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
5: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :4
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :5
3: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
4: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
5: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :3
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :3
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, quadruples#1^#(::(@x, @xs)) ->
c_1(triples^#(@xs), quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_2(attach3^#(@x, pairs(@xs)), triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil() }
No subproblems were checked.
* Path 1:{19,20}->2:{21,22}->5:{13,14}->11:{1,2}: MAYBE
-----------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :4
4: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :3
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
5: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :6
6: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :7
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :5
7: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :7
-->_3 pairs^#(@l) -> pairs#1^#(@l) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs: { append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :8
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :3
3: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :5
5: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :6
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :4
6: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :7
7: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :6
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
8: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :7
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :8
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
7: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
8: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {6} and add Pre({6}) = {5} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :6
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :7
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
6: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
7: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :5
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :6
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :7
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
5: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
6: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
7: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs#1^#(::(@x, @xs)) ->
c_1(append^#(attach(@x, @xs), pairs(@xs)), pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_2(triples^#(@xs), quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) -> c_3(pairs^#(@xs), triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil() }
No subproblems were checked.
* Path 1:{19,20}->2:{21,22}->5:{13,14}->8:{7,8}: MAYBE
----------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :2
2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
3: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :4
4: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :3
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
5: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :6
6: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :7
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :5
7: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :7
-->_3 pairs^#(@l) -> pairs#1^#(@l) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs: { attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :8
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :3
3: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :5
5: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :6
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :4
6: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :7
7: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :6
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
8: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :7
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :8
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
7: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
8: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {6} and add Pre({6}) = {5} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :6
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :7
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
6: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
7: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :5
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :6
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :7
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
5: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
6: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
7: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs#1^#(::(@x, @xs)) -> c_1(attach^#(@x, @xs), pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_2(triples^#(@xs), quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) -> c_3(pairs^#(@xs), triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
No rule is usable.
No subproblems were checked.
Arrrr..
tct-popstar
MAYBE
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We add following dependency tuples
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, append#1^#(nil(), @l2) -> c_3()
, append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, append3#1^#(nil(), @l2) -> c_6()
, append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, append4#1^#(nil(), @l2) -> c_9()
, attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, attach#1^#(nil(), @n) -> c_12()
, attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, attach3#1^#(nil(), @n) -> c_15()
, attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, attach4#1^#(nil(), @n) -> c_18()
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, pairs#1^#(nil()) -> c_21()
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, pairs'#1^#(nil()) -> c_24()
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, pairs_aux#1^#(nil(), @acc) -> c_27()
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, quadruples#1^#(nil()) -> c_30()
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
, triples#1^#(nil()) -> c_33() }
and replace the set of basic marked basic terms accordingly.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, append#1^#(nil(), @l2) -> c_3()
, append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, append3#1^#(nil(), @l2) -> c_6()
, append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, append4#1^#(nil(), @l2) -> c_9()
, attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, attach#1^#(nil(), @n) -> c_12()
, attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, attach3#1^#(nil(), @n) -> c_15()
, attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, attach4#1^#(nil(), @n) -> c_18()
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, pairs#1^#(nil()) -> c_21()
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, pairs'#1^#(nil()) -> c_24()
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, pairs_aux#1^#(nil(), @acc) -> c_27()
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, quadruples#1^#(nil()) -> c_30()
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
, triples#1^#(nil()) -> c_33() }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
-->_1 append#1^#(nil(), @l2) -> c_3() :3
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: append#1^#(nil(), @l2) -> c_3()
4: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :5
-->_1 append3#1^#(nil(), @l2) -> c_6() :6
5: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :4
6: append3#1^#(nil(), @l2) -> c_6()
7: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
-->_1 append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) :8
-->_1 append4#1^#(nil(), @l2) -> c_9() :9
8: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :7
9: append4#1^#(nil(), @l2) -> c_9()
10: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :11
-->_1 attach#1^#(nil(), @n) -> c_12() :12
11: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :10
12: attach#1^#(nil(), @n) -> c_12()
13: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :14
-->_1 attach3#1^#(nil(), @n) -> c_15() :15
14: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :13
15: attach3#1^#(nil(), @n) -> c_15()
16: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
-->_1 attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) :17
-->_1 attach4#1^#(nil(), @n) -> c_18() :18
17: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
-->_1 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :16
18: attach4#1^#(nil(), @n) -> c_18()
19: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :20
-->_1 pairs#1^#(nil()) -> c_21() :21
20: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :19
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :10
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
21: pairs#1^#(nil()) -> c_21()
22: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :23
-->_1 pairs'#1^#(nil()) -> c_24() :24
23: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :22
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :10
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
24: pairs'#1^#(nil()) -> c_24()
25: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :26
-->_1 pairs_aux#1^#(nil(), @acc) -> c_27() :27
26: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :25
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :10
-->_2 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
27: pairs_aux#1^#(nil(), @acc) -> c_27()
28: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :29
-->_1 quadruples#1^#(nil()) -> c_30() :30
29: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :31
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :28
-->_2 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :16
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :7
30: quadruples#1^#(nil()) -> c_30()
31: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :32
-->_1 triples#1^#(nil()) -> c_33() :33
32: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :31
-->_3 pairs^#(@l) -> pairs#1^#(@l) :19
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :13
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :4
33: triples#1^#(nil()) -> c_33()
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {30} and add Pre({30}) = {28} to the strict component.
- We remove {33} and add Pre({33}) = {31} to the strict component.
- We remove {27} and add Pre({27}) = {25} to the strict component.
- We remove {24} and add Pre({24}) = {22} to the strict component.
- We remove {21} and add Pre({21}) = {19} to the strict component.
- We remove {18} and add Pre({18}) = {16} to the strict component.
- We remove {15} and add Pre({15}) = {13} to the strict component.
- We remove {12} and add Pre({12}) = {10} to the strict component.
- We remove {9} and add Pre({9}) = {7} to the strict component.
- We remove {6} and add Pre({6}) = {4} to the strict component.
- We remove {3} and add Pre({3}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs:
{ append#1^#(nil(), @l2) -> c_3()
, append3#1^#(nil(), @l2) -> c_6()
, append4#1^#(nil(), @l2) -> c_9()
, attach#1^#(nil(), @n) -> c_12()
, attach3#1^#(nil(), @n) -> c_15()
, attach4#1^#(nil(), @n) -> c_18()
, pairs#1^#(nil()) -> c_21()
, pairs'#1^#(nil()) -> c_24()
, pairs_aux#1^#(nil(), @acc) -> c_27()
, quadruples#1^#(nil()) -> c_30()
, triples#1^#(nil()) -> c_33() }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the the dependency graph
->7:{15,16}
|
|->21:{1,2}
| |
| `->22:{23} Weak SCC
|
|->15:{7,8}
| |
| `->16:{26} Weak SCC
|
`->8:{30} Weak SCC
->5:{17,18}
|
|->21:{1,2}
| |
| `->22:{23} Weak SCC
|
|->15:{7,8}
| |
| `->16:{26} Weak SCC
|
`->6:{31} Weak SCC
->1:{19,20}
|
|->17:{5,6}
| |
| `->18:{25} Weak SCC
|
|->11:{11,12}
| |
| `->12:{28} Weak SCC
|
|->3:{21,22}
| |
| |->19:{3,4}
| | |
| | `->20:{24} Weak SCC
| |
| |->13:{9,10}
| | |
| | `->14:{27} Weak SCC
| |
| |->9:{13,14}
| | |
| | |->21:{1,2}
| | | |
| | | `->22:{23} Weak SCC
| | |
| | |->15:{7,8}
| | | |
| | | `->16:{26} Weak SCC
| | |
| | `->10:{29} Weak SCC
| |
| `->4:{33} Weak SCC
|
`->2:{32} Weak SCC
Here dependency-pairs are as follows:
Strict DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, 4: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, 5: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, 6: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, 7: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 8: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 9: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, 10: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, 11: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, 12: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, 13: pairs^#(@l) -> pairs#1^#(@l)
, 14: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, 15: pairs'^#(@l) -> pairs'#1^#(@l)
, 16: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, 17: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 18: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, 19: quadruples^#(@l) -> quadruples#1^#(@l)
, 20: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, 21: triples^#(@l) -> triples#1^#(@l)
, 22: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs:
{ 23: append#1^#(nil(), @l2) -> c_3()
, 24: append3#1^#(nil(), @l2) -> c_6()
, 25: append4#1^#(nil(), @l2) -> c_9()
, 26: attach#1^#(nil(), @n) -> c_12()
, 27: attach3#1^#(nil(), @n) -> c_15()
, 28: attach4#1^#(nil(), @n) -> c_18()
, 29: pairs#1^#(nil()) -> c_21()
, 30: pairs'#1^#(nil()) -> c_24()
, 31: pairs_aux#1^#(nil(), @acc) -> c_27()
, 32: quadruples#1^#(nil()) -> c_30()
, 33: triples#1^#(nil()) -> c_33() }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 32: quadruples#1^#(nil()) -> c_30()
, 33: triples#1^#(nil()) -> c_33()
, 31: pairs_aux#1^#(nil(), @acc) -> c_27()
, 30: pairs'#1^#(nil()) -> c_24()
, 29: pairs#1^#(nil()) -> c_21()
, 28: attach4#1^#(nil(), @n) -> c_18()
, 27: attach3#1^#(nil(), @n) -> c_15()
, 26: attach#1^#(nil(), @n) -> c_12()
, 25: append4#1^#(nil(), @l2) -> c_9()
, 24: append3#1^#(nil(), @l2) -> c_6()
, 23: append#1^#(nil(), @l2) -> c_3() }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We employ 'linear path analysis' using the following approximated
dependency graph:
->4:{15,16} [ ? ]
|
|->11:{1,2} [ YES(O(1),O(n^3)) ]
|
`->8:{7,8} [ YES(O(1),O(n^2)) ]
->3:{17,18} [ ? ]
|
|->11:{1,2} [ YES(O(1),O(n^2)) ]
|
`->8:{7,8} [ YES(O(1),O(n^2)) ]
->1:{19,20} [ ? ]
|
|->9:{5,6} [ MAYBE ]
|
|->6:{11,12} [ MAYBE ]
|
`->2:{21,22} [ ? ]
|
|->10:{3,4} [ MAYBE ]
|
|->7:{9,10} [ MAYBE ]
|
`->5:{13,14} [ ? ]
|
|->11:{1,2} [ MAYBE ]
|
`->8:{7,8} [ MAYBE ]
Here dependency-pairs are as follows:
Strict DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, 4: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, 5: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, 6: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, 7: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 8: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 9: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, 10: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, 11: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, 12: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, 13: pairs^#(@l) -> pairs#1^#(@l)
, 14: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, 15: pairs'^#(@l) -> pairs'#1^#(@l)
, 16: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
, 17: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 18: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
, 19: quadruples^#(@l) -> quadruples#1^#(@l)
, 20: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, 21: triples^#(@l) -> triples#1^#(@l)
, 22: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
* Path 4:{15,16}->11:{1,2}: YES(O(1),O(n^3))
------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :4
4: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :3
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak DPs: { append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :4
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :3
3: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the following dependency-graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :3
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :4
3: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
Remaining Rules (B):
{ pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { append^#(@l1, @l2) -> append#1^#(@l1, @l2) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) -> append^#(pairs'(@xs), attach(@x, @xs))
, pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) YES(O(1),O(n^1)).
Sub-proof:
----------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) :2
2: pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) :2
2: pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs'#1^#(::(@x, @xs)) ->
c_1(append^#(pairs'(@xs), attach(@x, @xs)), pairs'^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs: { pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
No rule is usable.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs: { pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'Small Polynomial Path Order (PS,1-bounded)'
to orient following rules strictly.
DPs:
{ 2: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,1-bounded)' as induced by the safe mapping
safe(append) = {}, safe(append#1) = {}, safe(::) = {1, 2},
safe(nil) = {}, safe(attach) = {}, safe(attach#1) = {},
safe(tuple#2) = {1, 2}, safe(pairs') = {}, safe(pairs'#1) = {},
safe(append^#) = {}, safe(append#1^#) = {}, safe(append3^#) = {},
safe(append3#1^#) = {}, safe(append4^#) = {},
safe(append4#1^#) = {}, safe(attach^#) = {}, safe(attach#1^#) = {},
safe(attach3^#) = {}, safe(attach3#1^#) = {}, safe(attach4^#) = {},
safe(attach4#1^#) = {}, safe(pairs^#) = {}, safe(pairs#1^#) = {},
safe(pairs'^#) = {}, safe(pairs'#1^#) = {}, safe(pairs_aux^#) = {},
safe(pairs_aux#1^#) = {}, safe(quadruples^#) = {},
safe(quadruples#1^#) = {}, safe(triples^#) = {},
safe(triples#1^#) = {}, safe(c_1) = {}, safe(c) = {}
and precedence
pairs'^# ~ pairs'#1^# .
Following symbols are considered recursive:
{}
The recursion depth is 0.
Further, following argument filtering is employed:
pi(append) = [], pi(append#1) = [], pi(::) = [2], pi(nil) = [],
pi(attach) = [], pi(attach#1) = [], pi(tuple#2) = [],
pi(pairs') = [], pi(pairs'#1) = [], pi(append^#) = [],
pi(append#1^#) = [], pi(append3^#) = [], pi(append3#1^#) = [],
pi(append4^#) = [], pi(append4#1^#) = [], pi(attach^#) = [],
pi(attach#1^#) = [], pi(attach3^#) = [], pi(attach3#1^#) = [],
pi(attach4^#) = [], pi(attach4#1^#) = [], pi(pairs^#) = [],
pi(pairs#1^#) = [], pi(pairs'^#) = 1, pi(pairs'#1^#) = 1,
pi(pairs_aux^#) = [], pi(pairs_aux#1^#) = [],
pi(quadruples^#) = [], pi(quadruples#1^#) = [], pi(triples^#) = [],
pi(triples#1^#) = [], pi(c_1) = [], pi(c) = []
Usable defined function symbols are a subset of:
{}
For your convenience, here are the satisfied ordering constraints:
pi(pairs'^#(@l)) = @l
>= @l
= pi(pairs'#1^#(@l))
pi(pairs'#1^#(::(@x, @xs))) = ::(; @xs)
> @xs
= pi(pairs'^#(@xs))
Processor 'Small Polynomial Path Order (PS,1-bounded)' induces the
complexity certificate YES(?,O(n^1)) on application of rules {2}.
Here rules are labeled according to the (estimated) dependency
graph
1: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) :2
2: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs)
-->_1 pairs'^#(@l) -> pairs'#1^#(@l) :1
- The rules {2} have known complexity. These cover all predecessors
of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules {1,2}
is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: pairs'^#(@l) -> pairs'#1^#(@l)
, 2: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 1: pairs'^#(@l) -> pairs'#1^#(@l)
, 2: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
We apply the transformation 'usablerules' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs: { append^#(@l1, @l2) -> append#1^#(@l1, @l2) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) -> append^#(pairs'(@xs), attach(@x, @xs))
, pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We use the processor 'custom shape polynomial interpretation' to
orient following rules strictly.
DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 4: pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs))
, 5: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Trs:
{ attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs)) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(append) = {}, Uargs(append#1) = {}, Uargs(::) = {},
Uargs(attach) = {}, Uargs(attach#1) = {}, Uargs(tuple#2) = {},
Uargs(pairs') = {}, Uargs(pairs'#1) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(append3^#) = {},
Uargs(append3#1^#) = {}, Uargs(append4^#) = {},
Uargs(append4#1^#) = {}, Uargs(attach^#) = {},
Uargs(attach#1^#) = {}, Uargs(attach3^#) = {},
Uargs(attach3#1^#) = {}, Uargs(attach4^#) = {},
Uargs(attach4#1^#) = {}, Uargs(pairs^#) = {},
Uargs(pairs#1^#) = {}, Uargs(pairs'^#) = {},
Uargs(pairs'#1^#) = {}, Uargs(pairs_aux^#) = {},
Uargs(pairs_aux#1^#) = {}, Uargs(quadruples^#) = {},
Uargs(quadruples#1^#) = {}, Uargs(triples^#) = {},
Uargs(triples#1^#) = {}
TcT has computed following constructor-restricted polynomial
interpretation.
[append](x1, x2) = x1 + 2*x2
[append#1](x1, x2) = x1 + 2*x2
[::](x1, x2) = 3 + x2
[nil]() = 0
[attach](x1, x2) = 2 + 3*x2
[attach#1](x1, x2) = 3*x1
[tuple#2](x1, x2) = 0
[pairs'](x1) = x1^2
[pairs'#1](x1) = x1^2
[append^#](x1, x2) = 1 + 2*x1
[append#1^#](x1, x2) = 2*x1
[append3^#](x1, x2) = 0
[append3#1^#](x1, x2) = 0
[append4^#](x1, x2) = 0
[append4#1^#](x1, x2) = 0
[attach^#](x1, x2) = 0
[attach#1^#](x1, x2) = 0
[attach3^#](x1, x2) = 0
[attach3#1^#](x1, x2) = 0
[attach4^#](x1, x2) = 0
[attach4#1^#](x1, x2) = 0
[pairs^#](x1) = 0
[pairs#1^#](x1) = 0
[pairs'^#](x1) = 1 + 2*x1^2
[pairs'#1^#](x1) = 2*x1^2
[pairs_aux^#](x1, x2) = 0
[pairs_aux#1^#](x1, x2) = 0
[quadruples^#](x1) = 0
[quadruples#1^#](x1) = 0
[triples^#](x1) = 0
[triples#1^#](x1) = 0
This order satisfies following ordering constraints
[append(@l1, @l2)] = @l1 + 2*@l2
>= @l1 + 2*@l2
= [append#1(@l1, @l2)]
[append#1(::(@x, @xs), @l2)] = 3 + @xs + 2*@l2
>= 3 + @xs + 2*@l2
= [::(@x, append(@xs, @l2))]
[append#1(nil(), @l2)] = 2*@l2
>= @l2
= [@l2]
[attach(@n, @l)] = 2 + 3*@l
> 3*@l
= [attach#1(@l, @n)]
[attach#1(::(@x, @xs), @n)] = 9 + 3*@xs
> 5 + 3*@xs
= [::(tuple#2(@n, @x), attach(@n, @xs))]
[attach#1(nil(), @n)] =
>=
= [nil()]
[pairs'(@l)] = @l^2
>= @l^2
= [pairs'#1(@l)]
[pairs'#1(::(@x, @xs))] = 9 + 6*@xs + @xs^2
> @xs^2 + 4 + 6*@xs
= [append(pairs'(@xs), attach(@x, @xs))]
[pairs'#1(nil())] =
>=
= [nil()]
[append^#(@l1, @l2)] = 1 + 2*@l1
> 2*@l1
= [append#1^#(@l1, @l2)]
[append#1^#(::(@x, @xs), @l2)] = 6 + 2*@xs
> 1 + 2*@xs
= [append^#(@xs, @l2)]
[pairs'^#(@l)] = 1 + 2*@l^2
> 2*@l^2
= [pairs'#1^#(@l)]
[pairs'#1^#(::(@x, @xs))] = 18 + 12*@xs + 2*@xs^2
> 1 + 2*@xs^2
= [append^#(pairs'(@xs), attach(@x, @xs))]
[pairs'#1^#(::(@x, @xs))] = 18 + 12*@xs + 2*@xs^2
> 1 + 2*@xs^2
= [pairs'^#(@xs)]
Processor 'custom shape polynomial interpretation' induces the
complexity certificate YES(?,O(n^2)) on application of rules
{1,2,3,4,5}. Here rules are labeled according to the (estimated)
dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) :5
-->_1 pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs)) :4
4: pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs))
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
5: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs)
-->_1 pairs'^#(@l) -> pairs'#1^#(@l) :3
Overall, we obtain that the number of applications of rules
{1,2,3,4,5} is given by YES(?,O(n^2)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) -> append^#(pairs'(@xs), attach(@x, @xs))
, pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{3,5} Weak SCC
|
`->2:{4} Weak SCC
|
`->3:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 4: pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs))
, 5: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 5: pairs'#1^#(::(@x, @xs)) -> pairs'^#(@xs)
, 4: pairs'#1^#(::(@x, @xs)) ->
append^#(pairs'(@xs), attach(@x, @xs))
, 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
* Path 4:{15,16}->8:{7,8}: YES(O(1),O(n^2))
-----------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :2
2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
3: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :4
4: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :3
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak DPs: { attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :4
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :3
3: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the following dependency-graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :3
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) :4
3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs))
-->_2 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs'#1^#(::(@x, @xs)) ->
c_23(append^#(pairs'(@xs), attach(@x, @xs)),
pairs'^#(@xs),
attach^#(@x, @xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
No rule is usable.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs'^#(@l) -> pairs'#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We use the processor 'Small Polynomial Path Order (PS,2-bounded)'
to orient following rules strictly.
DPs:
{ 3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 4: pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,2-bounded)' as induced by the safe mapping
safe(::) = {1, 2}, safe(nil) = {}, safe(tuple#2) = {1, 2},
safe(append^#) = {}, safe(append#1^#) = {}, safe(append3^#) = {},
safe(append3#1^#) = {}, safe(append4^#) = {},
safe(append4#1^#) = {}, safe(attach^#) = {}, safe(attach#1^#) = {},
safe(attach3^#) = {}, safe(attach3#1^#) = {}, safe(attach4^#) = {},
safe(attach4#1^#) = {}, safe(pairs^#) = {}, safe(pairs#1^#) = {},
safe(pairs'^#) = {}, safe(pairs'#1^#) = {}, safe(pairs_aux^#) = {},
safe(pairs_aux#1^#) = {}, safe(quadruples^#) = {},
safe(quadruples#1^#) = {}, safe(triples^#) = {},
safe(triples#1^#) = {}, safe(c_1) = {}
and precedence
pairs'#1^# > attach^#, attach^# ~ attach#1^#,
pairs'^# ~ pairs'#1^# .
Following symbols are considered recursive:
{pairs'^#, pairs'#1^#}
The recursion depth is 1.
Further, following argument filtering is employed:
pi(::) = [2], pi(nil) = [], pi(tuple#2) = [], pi(append^#) = [],
pi(append#1^#) = [], pi(append3^#) = [], pi(append3#1^#) = [],
pi(append4^#) = [], pi(append4#1^#) = [], pi(attach^#) = 2,
pi(attach#1^#) = 1, pi(attach3^#) = [], pi(attach3#1^#) = [],
pi(attach4^#) = [], pi(attach4#1^#) = [], pi(pairs^#) = [],
pi(pairs#1^#) = [], pi(pairs'^#) = [1], pi(pairs'#1^#) = [1],
pi(pairs_aux^#) = [], pi(pairs_aux#1^#) = [],
pi(quadruples^#) = [], pi(quadruples#1^#) = [], pi(triples^#) = [],
pi(triples#1^#) = [], pi(c_1) = [1, 2]
Usable defined function symbols are a subset of:
{}
For your convenience, here are the satisfied ordering constraints:
pi(attach^#(@n, @l)) = @l
>= @l
= pi(attach#1^#(@l, @n))
pi(attach#1^#(::(@x, @xs), @n)) = ::(; @xs)
> @xs
= pi(attach^#(@n, @xs))
pi(pairs'^#(@l)) = pairs'^#(@l;)
>= pairs'#1^#(@l;)
= pi(pairs'#1^#(@l))
pi(pairs'#1^#(::(@x, @xs))) = pairs'#1^#(::(; @xs);)
> c_1(pairs'^#(@xs;), @xs;)
= pi(c_1(pairs'^#(@xs), attach^#(@x, @xs)))
Processor 'Small Polynomial Path Order (PS,2-bounded)' induces the
complexity certificate YES(?,O(n^2)) on application of rules {3,4}.
Here rules are labeled according to the (estimated) dependency
graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :3
2: pairs'^#(@l) -> pairs'#1^#(@l)
-->_1 pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) :4
3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: pairs'#1^#(::(@x, @xs)) -> c_1(pairs'^#(@xs), attach^#(@x, @xs))
-->_1 pairs'^#(@l) -> pairs'#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
- The rules {3,4} have known complexity. These cover all
predecessors of {1,2}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4} is given by YES(?,O(n^2)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs'^#(@l) -> pairs'#1^#(@l)
, pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{3,4} Weak SCC
|
`->2:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 4: pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 3: pairs'^#(@l) -> pairs'#1^#(@l)
, 4: pairs'#1^#(::(@x, @xs)) ->
c_1(pairs'^#(@xs), attach^#(@x, @xs))
, 1: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
* Path 3:{17,18}->11:{1,2}: YES(O(1),O(n^2))
------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :4
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :3
-->_2 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak DPs: { append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :4
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :3
3: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_2 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the following dependency-graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :3
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :4
3: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_2 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We use the processor 'Small Polynomial Path Order (PS,2-bounded)'
to orient following rules strictly.
DPs:
{ 3: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,2-bounded)' as induced by the safe mapping
safe(append) = {}, safe(append#1) = {1}, safe(::) = {1, 2},
safe(nil) = {}, safe(attach) = {}, safe(attach#1) = {},
safe(tuple#2) = {1, 2}, safe(append^#) = {},
safe(append#1^#) = {2}, safe(append3^#) = {},
safe(append3#1^#) = {}, safe(append4^#) = {},
safe(append4#1^#) = {}, safe(attach^#) = {}, safe(attach#1^#) = {},
safe(attach3^#) = {}, safe(attach3#1^#) = {}, safe(attach4^#) = {},
safe(attach4#1^#) = {}, safe(pairs^#) = {}, safe(pairs#1^#) = {},
safe(pairs'^#) = {}, safe(pairs'#1^#) = {}, safe(pairs_aux^#) = {},
safe(pairs_aux#1^#) = {2}, safe(quadruples^#) = {},
safe(quadruples#1^#) = {}, safe(triples^#) = {},
safe(triples#1^#) = {}, safe(c_1) = {}
and precedence
append#1 > append, pairs_aux#1^# > append, pairs_aux#1^# > attach,
pairs_aux#1^# > append^#, attach ~ attach#1, append^# ~ append#1^#,
pairs_aux^# ~ pairs_aux#1^# .
Following symbols are considered recursive:
{pairs_aux^#, pairs_aux#1^#}
The recursion depth is 1.
Further, following argument filtering is employed:
pi(append) = [1], pi(append#1) = [1], pi(::) = [2], pi(nil) = [],
pi(attach) = 2, pi(attach#1) = 1, pi(tuple#2) = [],
pi(append^#) = 1, pi(append#1^#) = 1, pi(append3^#) = [],
pi(append3#1^#) = [], pi(append4^#) = [], pi(append4#1^#) = [],
pi(attach^#) = [], pi(attach#1^#) = [], pi(attach3^#) = [],
pi(attach3#1^#) = [], pi(attach4^#) = [], pi(attach4#1^#) = [],
pi(pairs^#) = [], pi(pairs#1^#) = [], pi(pairs'^#) = [],
pi(pairs'#1^#) = [], pi(pairs_aux^#) = [1],
pi(pairs_aux#1^#) = [1], pi(quadruples^#) = [],
pi(quadruples#1^#) = [], pi(triples^#) = [], pi(triples#1^#) = [],
pi(c_1) = [1, 2]
Usable defined function symbols are a subset of:
{attach, attach#1}
For your convenience, here are the satisfied ordering constraints:
pi(append^#(@l1, @l2)) = @l1
>= @l1
= pi(append#1^#(@l1, @l2))
pi(append#1^#(::(@x, @xs), @l2)) = ::(; @xs)
> @xs
= pi(append^#(@xs, @l2))
pi(pairs_aux^#(@l, @acc)) = pairs_aux^#(@l;)
>= pairs_aux#1^#(@l;)
= pi(pairs_aux#1^#(@l, @acc))
pi(pairs_aux#1^#(::(@x, @xs), @acc)) = pairs_aux#1^#(::(; @xs);)
> c_1(pairs_aux^#(@xs;), @xs;)
= pi(c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)))
pi(attach(@n, @l)) = @l
>= @l
= pi(attach#1(@l, @n))
pi(attach#1(::(@x, @xs), @n)) = ::(; @xs)
>= ::(; @xs)
= pi(::(tuple#2(@n, @x), attach(@n, @xs)))
pi(attach#1(nil(), @n)) = nil()
>= nil()
= pi(nil())
Processor 'Small Polynomial Path Order (PS,2-bounded)' induces the
complexity certificate YES(?,O(n^2)) on application of rules {3,4}.
Here rules are labeled according to the (estimated) dependency
graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :3
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) :4
3: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_2 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
- The rules {3,4} have known complexity. These cover all
predecessors of {1,2}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4} is given by YES(?,O(n^2)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{3,4} Weak SCC
|
`->2:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, 3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc))
, 1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, 2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
* Path 3:{17,18}->8:{7,8}: YES(O(1),O(n^2))
-----------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :2
2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :4
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :3
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak DPs: { attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :4
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :3
3: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the following dependency-graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :3
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) :4
3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_3 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs_aux#1^#(::(@x, @xs), @acc) ->
c_26(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
append^#(attach(@x, @xs), @acc),
attach^#(@x, @xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We use the processor 'Small Polynomial Path Order (PS,2-bounded)'
to orient following rules strictly.
DPs:
{ 3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,2-bounded)' as induced by the safe mapping
safe(append) = {}, safe(append#1) = {}, safe(::) = {1, 2},
safe(nil) = {}, safe(attach) = {}, safe(attach#1) = {2},
safe(tuple#2) = {1, 2}, safe(append^#) = {}, safe(append#1^#) = {},
safe(append3^#) = {}, safe(append3#1^#) = {}, safe(append4^#) = {},
safe(append4#1^#) = {}, safe(attach^#) = {},
safe(attach#1^#) = {2}, safe(attach3^#) = {},
safe(attach3#1^#) = {}, safe(attach4^#) = {},
safe(attach4#1^#) = {}, safe(pairs^#) = {}, safe(pairs#1^#) = {},
safe(pairs'^#) = {}, safe(pairs'#1^#) = {}, safe(pairs_aux^#) = {},
safe(pairs_aux#1^#) = {2}, safe(quadruples^#) = {},
safe(quadruples#1^#) = {}, safe(triples^#) = {},
safe(triples#1^#) = {}, safe(c_1) = {}
and precedence
append > append#1, pairs_aux#1^# > attach^#, attach^# ~ attach#1^#,
pairs_aux^# ~ pairs_aux#1^# .
Following symbols are considered recursive:
{pairs_aux^#, pairs_aux#1^#}
The recursion depth is 1.
Further, following argument filtering is employed:
pi(append) = 1, pi(append#1) = [1], pi(::) = [2], pi(nil) = [],
pi(attach) = 2, pi(attach#1) = [2], pi(tuple#2) = [],
pi(append^#) = [], pi(append#1^#) = [], pi(append3^#) = [],
pi(append3#1^#) = [], pi(append4^#) = [], pi(append4#1^#) = [],
pi(attach^#) = 2, pi(attach#1^#) = 1, pi(attach3^#) = [],
pi(attach3#1^#) = [], pi(attach4^#) = [], pi(attach4#1^#) = [],
pi(pairs^#) = [], pi(pairs#1^#) = [], pi(pairs'^#) = [],
pi(pairs'#1^#) = [], pi(pairs_aux^#) = [1],
pi(pairs_aux#1^#) = [1], pi(quadruples^#) = [],
pi(quadruples#1^#) = [], pi(triples^#) = [], pi(triples#1^#) = [],
pi(c_1) = [1, 2]
Usable defined function symbols are a subset of:
{}
For your convenience, here are the satisfied ordering constraints:
pi(attach^#(@n, @l)) = @l
>= @l
= pi(attach#1^#(@l, @n))
pi(attach#1^#(::(@x, @xs), @n)) = ::(; @xs)
> @xs
= pi(attach^#(@n, @xs))
pi(pairs_aux^#(@l, @acc)) = pairs_aux^#(@l;)
>= pairs_aux#1^#(@l;)
= pi(pairs_aux#1^#(@l, @acc))
pi(pairs_aux#1^#(::(@x, @xs), @acc)) = pairs_aux#1^#(::(; @xs);)
> c_1(pairs_aux^#(@xs;), @xs;)
= pi(c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)))
Processor 'Small Polynomial Path Order (PS,2-bounded)' induces the
complexity certificate YES(?,O(n^2)) on application of rules {3,4}.
Here rules are labeled according to the (estimated) dependency
graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :3
2: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
-->_1 pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) :4
3: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs))
-->_1 pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
- The rules {3,4} have known complexity. These cover all
predecessors of {1,2}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4} is given by YES(?,O(n^2)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{3,4} Weak SCC
|
`->2:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, 3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 3: pairs_aux^#(@l, @acc) -> pairs_aux#1^#(@l, @acc)
, 4: pairs_aux#1^#(::(@x, @xs), @acc) ->
c_1(pairs_aux^#(@xs, append(attach(@x, @xs), @acc)),
attach^#(@x, @xs))
, 1: attach^#(@n, @l) -> attach#1^#(@l, @n)
, 2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
* Path 1:{19,20}->9:{5,6}: MAYBE
------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
-->_1 append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) :2
2: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak DPs: { append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
-->_1 append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) :4
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
4: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
-->_1 append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) :3
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
3: append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
-->_1 append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
None of the processors succeeded.
Details of failed attempt(s):
-----------------------------
1) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
2) 'With Problem ...' failed due to the following reason:
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ append4^#(@l1, @l2) -> append4#1^#(@l1, @l2)
, append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2) }
Remaining Rules (B):
{ quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) }
Weak DPs:
{ append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
append4^#(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) YES(O(1),O(n^1)).
Sub-proof:
----------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) :2
2: quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs))
-->_2 quadruples^#(@l) -> quadruples#1^#(@l) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) :2
2: quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs))
-->_2 quadruples^#(@l) -> quadruples#1^#(@l) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_1(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
quadruples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs: { quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
No rule is usable.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs: { quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'Small Polynomial Path Order (PS,1-bounded)'
to orient following rules strictly.
DPs:
{ 2: quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,1-bounded)' as induced by the safe mapping
safe(append) = {}, safe(append#1) = {}, safe(::) = {1, 2},
safe(nil) = {}, safe(append3) = {}, safe(append3#1) = {},
safe(append4) = {}, safe(append4#1) = {}, safe(attach) = {},
safe(attach#1) = {}, safe(tuple#2) = {1, 2}, safe(attach3) = {},
safe(attach3#1) = {}, safe(attach4) = {}, safe(attach4#1) = {},
safe(pairs) = {}, safe(pairs#1) = {}, safe(quadruples) = {},
safe(quadruples#1) = {}, safe(triples) = {}, safe(triples#1) = {},
safe(append^#) = {}, safe(append#1^#) = {}, safe(append3^#) = {},
safe(append3#1^#) = {}, safe(append4^#) = {},
safe(append4#1^#) = {}, safe(attach^#) = {}, safe(attach#1^#) = {},
safe(attach3^#) = {}, safe(attach3#1^#) = {}, safe(attach4^#) = {},
safe(attach4#1^#) = {}, safe(pairs^#) = {}, safe(pairs#1^#) = {},
safe(pairs'^#) = {}, safe(pairs'#1^#) = {}, safe(pairs_aux^#) = {},
safe(pairs_aux#1^#) = {}, safe(quadruples^#) = {},
safe(quadruples#1^#) = {}, safe(triples^#) = {},
safe(triples#1^#) = {}, safe(c_1) = {}, safe(c) = {}
and precedence
quadruples^# ~ quadruples#1^# .
Following symbols are considered recursive:
{}
The recursion depth is 0.
Further, following argument filtering is employed:
pi(append) = [], pi(append#1) = [], pi(::) = [2], pi(nil) = [],
pi(append3) = [], pi(append3#1) = [], pi(append4) = [],
pi(append4#1) = [], pi(attach) = [], pi(attach#1) = [],
pi(tuple#2) = [], pi(attach3) = [], pi(attach3#1) = [],
pi(attach4) = [], pi(attach4#1) = [], pi(pairs) = [],
pi(pairs#1) = [], pi(quadruples) = [], pi(quadruples#1) = [],
pi(triples) = [], pi(triples#1) = [], pi(append^#) = [],
pi(append#1^#) = [], pi(append3^#) = [], pi(append3#1^#) = [],
pi(append4^#) = [], pi(append4#1^#) = [], pi(attach^#) = [],
pi(attach#1^#) = [], pi(attach3^#) = [], pi(attach3#1^#) = [],
pi(attach4^#) = [], pi(attach4#1^#) = [], pi(pairs^#) = [],
pi(pairs#1^#) = [], pi(pairs'^#) = [], pi(pairs'#1^#) = [],
pi(pairs_aux^#) = [], pi(pairs_aux#1^#) = [], pi(quadruples^#) = 1,
pi(quadruples#1^#) = 1, pi(triples^#) = [], pi(triples#1^#) = [],
pi(c_1) = [], pi(c) = []
Usable defined function symbols are a subset of:
{}
For your convenience, here are the satisfied ordering constraints:
pi(quadruples^#(@l)) = @l
>= @l
= pi(quadruples#1^#(@l))
pi(quadruples#1^#(::(@x, @xs))) = ::(; @xs)
> @xs
= pi(quadruples^#(@xs))
Processor 'Small Polynomial Path Order (PS,1-bounded)' induces the
complexity certificate YES(?,O(n^1)) on application of rules {2}.
Here rules are labeled according to the (estimated) dependency
graph
1: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) :2
2: quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs)
-->_1 quadruples^#(@l) -> quadruples#1^#(@l) :1
- The rules {2} have known complexity. These cover all predecessors
of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules {1,2}
is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: quadruples^#(@l) -> quadruples#1^#(@l)
, 2: quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 1: quadruples^#(@l) -> quadruples#1^#(@l)
, 2: quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
We apply the transformation 'usablerules' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs: { append4^#(@l1, @l2) -> append4#1^#(@l1, @l2) }
Weak DPs:
{ append4#1^#(::(@x, @xs), @l2) -> append4^#(@xs, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
append4^#(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1^#(::(@x, @xs)) -> quadruples^#(@xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
None of the processors succeeded.
Details of failed attempt(s):
-----------------------------
1) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
2) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
* Path 1:{19,20}->6:{11,12}: MAYBE
--------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
-->_1 attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) :2
2: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
-->_1 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
-->_2 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak DPs: { attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
-->_1 attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) :4
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
-->_2 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
4: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
-->_1 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: attach4^#(@n, @l) -> attach4#1^#(@l, @n)
-->_1 attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs) :3
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
3: attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
-->_1 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
-->_2 attach4^#(@n, @l) -> attach4#1^#(@l, @n) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach4^#(@n, @l) -> attach4#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l) }
Weak DPs:
{ attach4#1^#(::(@x, @xs), @n) -> attach4^#(@n, @xs)
, quadruples#1^#(::(@x, @xs)) ->
c_1(attach4^#(@x, triples(@xs)), quadruples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
No subproblems were checked.
* Path 1:{19,20}->2:{21,22}->10:{3,4}: MAYBE
------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :2
2: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs: { append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :6
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :5
5: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
6: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :5
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
5: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
-->_1 append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2) :4
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :5
3: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
4: append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
5: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :3
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :3
-->_1 append3^#(@l1, @l2) -> append3#1^#(@l1, @l2) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append3^#(@l1, @l2) -> append3#1^#(@l1, @l2)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append3#1^#(::(@x, @xs), @l2) -> append3^#(@xs, @l2)
, quadruples#1^#(::(@x, @xs)) ->
c_1(triples^#(@xs), quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_2(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
No subproblems were checked.
* Path 1:{19,20}->2:{21,22}->7:{9,10}: MAYBE
------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :2
2: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs: { attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :6
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :5
5: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
6: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :5
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :3
3: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
5: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: attach3^#(@n, @l) -> attach3#1^#(@l, @n)
-->_1 attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs) :4
2: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :5
3: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
4: attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
-->_1 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
5: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :3
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :2
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :3
-->_2 attach3^#(@n, @l) -> attach3#1^#(@l, @n) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach3^#(@n, @l) -> attach3#1^#(@l, @n)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach3#1^#(::(@x, @xs), @n) -> attach3^#(@n, @xs)
, quadruples#1^#(::(@x, @xs)) ->
c_1(triples^#(@xs), quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_2(attach3^#(@x, pairs(@xs)), triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil() }
No subproblems were checked.
* Path 1:{19,20}->2:{21,22}->5:{13,14}->11:{1,2}: MAYBE
-----------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :2
2: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
3: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :4
4: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :3
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
5: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :6
6: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :7
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :5
7: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :7
-->_3 pairs^#(@l) -> pairs#1^#(@l) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs: { append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :8
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :3
3: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
4: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :5
5: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :6
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :4
6: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :7
7: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :6
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
8: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :7
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :8
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
7: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
8: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {6} and add Pre({6}) = {5} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :6
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :7
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
6: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
7: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append^#(@l1, @l2) -> append#1^#(@l1, @l2)
-->_1 append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2) :5
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :6
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :7
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
5: append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
6: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_1 append^#(@l1, @l2) -> append#1^#(@l1, @l2) :1
7: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l1, @l2) -> append#1^#(@l1, @l2)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @l2) -> append^#(@xs, @l2)
, pairs#1^#(::(@x, @xs)) ->
c_1(append^#(attach(@x, @xs), pairs(@xs)), pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_2(triples^#(@xs), quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) -> c_3(pairs^#(@xs), triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil() }
No subproblems were checked.
* Path 1:{19,20}->2:{21,22}->5:{13,14}->8:{7,8}: MAYBE
----------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :2
2: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
3: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :4
4: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :3
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
5: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :6
6: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :7
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :5
7: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :7
-->_3 pairs^#(@l) -> pairs#1^#(@l) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs: { attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :8
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :3
3: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
4: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :5
5: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :6
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :4
6: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :7
7: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :6
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
8: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l)
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :7
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :8
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :6
6: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
7: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
8: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {6} and add Pre({6}) = {5} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :6
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :7
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :4
4: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :5
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
5: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
6: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
7: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :5
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: attach^#(@n, @l) -> attach#1^#(@l, @n)
-->_1 attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs) :5
2: pairs^#(@l) -> pairs#1^#(@l)
-->_1 pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs)) :6
3: quadruples^#(@l) -> quadruples#1^#(@l)
-->_1 quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs)) :7
4: triples^#(@l) -> triples#1^#(@l)
-->_1 triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) :8
5: attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
-->_1 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
6: pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
-->_2 attach^#(@n, @l) -> attach#1^#(@l, @n) :1
7: quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
-->_3 triples^#(@l) -> triples#1^#(@l) :4
-->_4 quadruples^#(@l) -> quadruples#1^#(@l) :3
8: triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs))
-->_4 triples^#(@l) -> triples#1^#(@l) :4
-->_3 pairs^#(@l) -> pairs#1^#(@l) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ pairs#1^#(::(@x, @xs)) ->
c_20(append^#(attach(@x, @xs), pairs(@xs)),
attach^#(@x, @xs),
pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_29(append4^#(attach4(@x, triples(@xs)), quadruples(@xs)),
attach4^#(@x, triples(@xs)),
triples^#(@xs),
quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) ->
c_32(append3^#(attach3(@x, pairs(@xs)), triples(@xs)),
attach3^#(@x, pairs(@xs)),
pairs^#(@xs),
triples^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@n, @l) -> attach#1^#(@l, @n)
, pairs^#(@l) -> pairs#1^#(@l)
, quadruples^#(@l) -> quadruples#1^#(@l)
, triples^#(@l) -> triples#1^#(@l) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @n) -> attach^#(@n, @xs)
, pairs#1^#(::(@x, @xs)) -> c_1(attach^#(@x, @xs), pairs^#(@xs))
, quadruples#1^#(::(@x, @xs)) ->
c_2(triples^#(@xs), quadruples^#(@xs))
, triples#1^#(::(@x, @xs)) -> c_3(pairs^#(@xs), triples^#(@xs)) }
Weak Trs:
{ append(@l1, @l2) -> append#1(@l1, @l2)
, append#1(::(@x, @xs), @l2) -> ::(@x, append(@xs, @l2))
, append#1(nil(), @l2) -> @l2
, append3(@l1, @l2) -> append3#1(@l1, @l2)
, append3#1(::(@x, @xs), @l2) -> ::(@x, append3(@xs, @l2))
, append3#1(nil(), @l2) -> @l2
, append4(@l1, @l2) -> append4#1(@l1, @l2)
, append4#1(::(@x, @xs), @l2) -> ::(@x, append4(@xs, @l2))
, append4#1(nil(), @l2) -> @l2
, attach(@n, @l) -> attach#1(@l, @n)
, attach#1(::(@x, @xs), @n) -> ::(tuple#2(@n, @x), attach(@n, @xs))
, attach#1(nil(), @n) -> nil()
, attach3(@n, @l) -> attach3#1(@l, @n)
, attach3#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach3(@n, @xs))
, attach3#1(nil(), @n) -> nil()
, attach4(@n, @l) -> attach4#1(@l, @n)
, attach4#1(::(@x, @xs), @n) ->
::(tuple#2(@n, @x), attach4(@n, @xs))
, attach4#1(nil(), @n) -> nil()
, pairs(@l) -> pairs#1(@l)
, pairs#1(::(@x, @xs)) -> append(attach(@x, @xs), pairs(@xs))
, pairs#1(nil()) -> nil()
, pairs'(@l) -> pairs'#1(@l)
, pairs'#1(::(@x, @xs)) -> append(pairs'(@xs), attach(@x, @xs))
, pairs'#1(nil()) -> nil()
, pairs_aux(@l, @acc) -> pairs_aux#1(@l, @acc)
, pairs_aux#1(::(@x, @xs), @acc) ->
pairs_aux(@xs, append(attach(@x, @xs), @acc))
, pairs_aux#1(nil(), @acc) -> @acc
, quadruples(@l) -> quadruples#1(@l)
, quadruples#1(::(@x, @xs)) ->
append4(attach4(@x, triples(@xs)), quadruples(@xs))
, quadruples#1(nil()) -> nil()
, triples(@l) -> triples#1(@l)
, triples#1(::(@x, @xs)) ->
append3(attach3(@x, pairs(@xs)), triples(@xs))
, triples#1(nil()) -> nil() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
No rule is usable.
No subproblems were checked.
Arrrr..