tct
MAYBE
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, +(@x, @y) -> #add(@x, @y)
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m)) }
Weak Trs:
{ #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We add following dependency tuples
Strict DPs:
{ #abs^#(#0()) -> c_1()
, #abs^#(#neg(@x)) -> c_2()
, #abs^#(#pos(@x)) -> c_3()
, #abs^#(#s(@x)) -> c_4()
, *^#(@x, @y) -> #mult^#(@x, @y)
, +^#(@x, @y) -> #add^#(@x, @y)
, attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#1^#(nil(), @m) -> c_9()
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, attach#2^#(nil(), @x, @xs) -> c_11()
, lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
, lineMult#1^#(nil(), @l) -> c_14()
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, mult#1^#(nil(), @l2) -> #abs^#(#0())
, makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, makeBase#1^#(nil()) -> c_18()
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, mkBase#1^#(nil()) -> c_32()
, matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, transAcc#1^#(nil(), @base) -> c_44()
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult'#1^#(nil(), @m2) -> c_24()
, matrixMult3^#(@m1, @m2, @m3) ->
c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, matrixMultList#1^#(nil(), @acc) -> c_28()
, matrixMultOld^#(@m1, @m2) ->
c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m))
, transpose#1^#(nil(), @m) -> c_46()
, mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
, mult#2^#(nil(), @x, @xs) -> #abs^#(#0())
, split^#(@m) -> split#1^#(@m)
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#1^#(nil()) -> c_39()
, split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
, split#2^#(nil(), @ls) -> c_41()
, split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
, transpose#3^#(nil(), @l) -> c_49()
, transpose'^#(@m) ->
c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ #mult^#(#0(), #0()) -> c_51()
, #mult^#(#0(), #neg(@y)) -> c_52()
, #mult^#(#0(), #pos(@y)) -> c_53()
, #mult^#(#neg(@x), #0()) -> c_54()
, #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y)
, #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y)
, #mult^#(#pos(@x), #0()) -> c_57()
, #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y)
, #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y)
, #add^#(#0(), @y) -> c_60()
, #add^#(#neg(#s(#0())), @y) -> #pred^#(@y)
, #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, #add^#(#pos(#s(#0())), @y) -> #succ^#(@y)
, #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, #natmult^#(#0(), @y) -> c_73()
, #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y))
, #pred^#(#0()) -> c_65()
, #pred^#(#neg(#s(@x))) -> c_66()
, #pred^#(#pos(#s(#0()))) -> c_67()
, #pred^#(#pos(#s(#s(@x)))) -> c_68()
, #succ^#(#0()) -> c_69()
, #succ^#(#neg(#s(#0()))) -> c_70()
, #succ^#(#neg(#s(#s(@x)))) -> c_71()
, #succ^#(#pos(#s(@x))) -> c_72() }
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:
{ #abs^#(#0()) -> c_1()
, #abs^#(#neg(@x)) -> c_2()
, #abs^#(#pos(@x)) -> c_3()
, #abs^#(#s(@x)) -> c_4()
, *^#(@x, @y) -> #mult^#(@x, @y)
, +^#(@x, @y) -> #add^#(@x, @y)
, attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#1^#(nil(), @m) -> c_9()
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, attach#2^#(nil(), @x, @xs) -> c_11()
, lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
, lineMult#1^#(nil(), @l) -> c_14()
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, mult#1^#(nil(), @l2) -> #abs^#(#0())
, makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, makeBase#1^#(nil()) -> c_18()
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, mkBase#1^#(nil()) -> c_32()
, matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, transAcc#1^#(nil(), @base) -> c_44()
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult'#1^#(nil(), @m2) -> c_24()
, matrixMult3^#(@m1, @m2, @m3) ->
c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, matrixMultList#1^#(nil(), @acc) -> c_28()
, matrixMultOld^#(@m1, @m2) ->
c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m))
, transpose#1^#(nil(), @m) -> c_46()
, mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
, mult#2^#(nil(), @x, @xs) -> #abs^#(#0())
, split^#(@m) -> split#1^#(@m)
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#1^#(nil()) -> c_39()
, split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
, split#2^#(nil(), @ls) -> c_41()
, split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
, transpose#3^#(nil(), @l) -> c_49()
, transpose'^#(@m) ->
c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ #mult^#(#0(), #0()) -> c_51()
, #mult^#(#0(), #neg(@y)) -> c_52()
, #mult^#(#0(), #pos(@y)) -> c_53()
, #mult^#(#neg(@x), #0()) -> c_54()
, #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y)
, #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y)
, #mult^#(#pos(@x), #0()) -> c_57()
, #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y)
, #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y)
, #add^#(#0(), @y) -> c_60()
, #add^#(#neg(#s(#0())), @y) -> #pred^#(@y)
, #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, #add^#(#pos(#s(#0())), @y) -> #succ^#(@y)
, #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, #natmult^#(#0(), @y) -> c_73()
, #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y))
, #pred^#(#0()) -> c_65()
, #pred^#(#neg(#s(@x))) -> c_66()
, #pred^#(#pos(#s(#0()))) -> c_67()
, #pred^#(#pos(#s(#s(@x)))) -> c_68()
, #succ^#(#0()) -> c_69()
, #succ^#(#neg(#s(#0()))) -> c_70()
, #succ^#(#neg(#s(#s(@x)))) -> c_71()
, #succ^#(#pos(#s(@x))) -> c_72() }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: #abs^#(#0()) -> c_1()
2: #abs^#(#neg(@x)) -> c_2()
3: #abs^#(#pos(@x)) -> c_3()
4: #abs^#(#s(@x)) -> c_4()
5: *^#(@x, @y) -> #mult^#(@x, @y)
-->_1 #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y) :59
-->_1 #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y) :58
-->_1 #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y) :56
-->_1 #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y) :55
-->_1 #mult^#(#pos(@x), #0()) -> c_57() :57
-->_1 #mult^#(#neg(@x), #0()) -> c_54() :54
-->_1 #mult^#(#0(), #pos(@y)) -> c_53() :53
-->_1 #mult^#(#0(), #neg(@y)) -> c_52() :52
-->_1 #mult^#(#0(), #0()) -> c_51() :51
6: +^#(@x, @y) -> #add^#(@x, @y)
-->_1 #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64
-->_1 #add^#(#pos(#s(#0())), @y) -> #succ^#(@y) :63
-->_1 #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :62
-->_1 #add^#(#neg(#s(#0())), @y) -> #pred^#(@y) :61
-->_1 #add^#(#0(), @y) -> c_60() :60
7: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :8
-->_1 attach#1^#(nil(), @m) -> c_9() :9
8: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :10
-->_1 attach#2^#(nil(), @x, @xs) -> c_11() :11
9: attach#1^#(nil(), @m) -> c_9()
10: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :7
11: attach#2^#(nil(), @x, @xs) -> c_11()
12: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) :13
-->_1 lineMult#1^#(nil(), @l) -> c_14() :14
13: lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :15
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :12
14: lineMult#1^#(nil(), @l) -> c_14()
15: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(nil(), @l2) -> #abs^#(#0()) :17
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :16
16: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(nil(), @x, @xs) -> #abs^#(#0()) :40
-->_1 mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)),
*^#(@x, @y),
mult^#(@xs, @ys)) :39
17: mult#1^#(nil(), @l2) -> #abs^#(#0())
-->_1 #abs^#(#0()) -> c_1() :1
18: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :19
-->_1 makeBase#1^#(nil()) -> c_18() :20
19: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :21
20: makeBase#1^#(nil()) -> c_18()
21: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :22
-->_1 mkBase#1^#(nil()) -> c_32() :23
22: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :21
23: mkBase#1^#(nil()) -> c_32()
24: matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :26
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :25
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :18
25: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :29
-->_1 matrixMult'#1^#(nil(), @m2) -> c_24() :30
26: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)),
transAcc^#(@m', @base)) :27
-->_1 transAcc#1^#(nil(), @base) -> c_44() :28
27: transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :26
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :7
28: transAcc#1^#(nil(), @base) -> c_44()
29: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :25
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :12
30: matrixMult'#1^#(nil(), @m2) -> c_24()
31: matrixMult3^#(@m1, @m2, @m3) ->
c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :24
-->_1 matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :24
32: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :33
-->_1 matrixMultList#1^#(nil(), @acc) -> c_28() :34
33: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :32
-->_2 matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :24
34: matrixMultList#1^#(nil(), @acc) -> c_28()
35: matrixMultOld^#(@m1, @m2) ->
c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_2 transpose^#(@m) -> transpose#1^#(@m, @m) :36
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :25
36: transpose^#(@m) -> transpose#1^#(@m, @m)
-->_1 transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m)) :37
-->_1 transpose#1^#(nil(), @m) -> c_46() :38
37: transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m))
-->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :47
-->_2 split^#(@m) -> split#1^#(@m) :41
38: transpose#1^#(nil(), @m) -> c_46()
39: mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
-->_3 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :15
-->_1 +^#(@x, @y) -> #add^#(@x, @y) :6
-->_2 *^#(@x, @y) -> #mult^#(@x, @y) :5
40: mult#2^#(nil(), @x, @xs) -> #abs^#(#0())
-->_1 #abs^#(#0()) -> c_1() :1
41: split^#(@m) -> split#1^#(@m)
-->_1 split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) :42
-->_1 split#1^#(nil()) -> c_39() :43
42: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
-->_1 split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) :44
-->_1 split#2^#(nil(), @ls) -> c_41() :45
43: split#1^#(nil()) -> c_39()
44: split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
-->_1 split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() :46
-->_2 split^#(@m) -> split#1^#(@m) :41
45: split#2^#(nil(), @ls) -> c_41()
46: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
47: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
-->_1 transpose#3^#(::(@y, @ys), @l) ->
transpose^#(::(@y, @ys)) :48
-->_1 transpose#3^#(nil(), @l) -> c_49() :49
48: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :36
49: transpose#3^#(nil(), @l) -> c_49()
50: transpose'^#(@m) ->
c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_1 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :26
-->_2 makeBase^#(@m) -> makeBase#1^#(@m) :18
51: #mult^#(#0(), #0()) -> c_51()
52: #mult^#(#0(), #neg(@y)) -> c_52()
53: #mult^#(#0(), #pos(@y)) -> c_53()
54: #mult^#(#neg(@x), #0()) -> c_54()
55: #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y)
-->_1 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_1 #natmult^#(#0(), @y) -> c_73() :65
56: #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y)
-->_1 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_1 #natmult^#(#0(), @y) -> c_73() :65
57: #mult^#(#pos(@x), #0()) -> c_57()
58: #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y)
-->_1 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_1 #natmult^#(#0(), @y) -> c_73() :65
59: #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y)
-->_1 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_1 #natmult^#(#0(), @y) -> c_73() :65
60: #add^#(#0(), @y) -> c_60()
61: #add^#(#neg(#s(#0())), @y) -> #pred^#(@y)
-->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70
-->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69
-->_1 #pred^#(#neg(#s(@x))) -> c_66() :68
-->_1 #pred^#(#0()) -> c_65() :67
62: #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
-->_2 #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64
-->_2 #add^#(#pos(#s(#0())), @y) -> #succ^#(@y) :63
-->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70
-->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69
-->_1 #pred^#(#neg(#s(@x))) -> c_66() :68
-->_1 #pred^#(#0()) -> c_65() :67
63: #add^#(#pos(#s(#0())), @y) -> #succ^#(@y)
-->_1 #succ^#(#pos(#s(@x))) -> c_72() :74
-->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73
-->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72
-->_1 #succ^#(#0()) -> c_69() :71
64: #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
-->_1 #succ^#(#pos(#s(@x))) -> c_72() :74
-->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73
-->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72
-->_1 #succ^#(#0()) -> c_69() :71
-->_2 #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64
-->_2 #add^#(#pos(#s(#0())), @y) -> #succ^#(@y) :63
65: #natmult^#(#0(), @y) -> c_73()
66: #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y))
-->_2 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_2 #natmult^#(#0(), @y) -> c_73() :65
-->_1 #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64
-->_1 #add^#(#pos(#s(#0())), @y) -> #succ^#(@y) :63
67: #pred^#(#0()) -> c_65()
68: #pred^#(#neg(#s(@x))) -> c_66()
69: #pred^#(#pos(#s(#0()))) -> c_67()
70: #pred^#(#pos(#s(#s(@x)))) -> c_68()
71: #succ^#(#0()) -> c_69()
72: #succ^#(#neg(#s(#0()))) -> c_70()
73: #succ^#(#neg(#s(#s(@x)))) -> c_71()
74: #succ^#(#pos(#s(@x))) -> c_72()
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {38} and add Pre({38}) = {36} to the strict component.
- We remove {43} and add Pre({43}) = {41} to the strict component.
- We remove {45} and add Pre({45}) = {42} to the strict component.
- We remove {46} and add Pre({46}) = {44} to the strict component.
- We remove {49} and add Pre({49}) = {47} to the strict component.
- We remove {34} and add Pre({34}) = {32} to the strict component.
- We remove {30} and add Pre({30}) = {25} to the strict component.
- We remove {28} and add Pre({28}) = {26} to the strict component.
- We remove {20} and add Pre({20}) = {18} to the strict component.
- We remove {23} and add Pre({23}) = {21} to the strict component.
- We remove {14} and add Pre({14}) = {12} to the strict component.
- We remove {9} and add Pre({9}) = {7} to the strict component.
- We remove {11} and add Pre({11}) = {8} to the strict component.
- We remove {6} and add Pre({6}) = {39} to the strict component.
- We remove {5} and add Pre({5}) = {39} to the strict component.
- We remove {4} and add Pre({4}) = {} to the strict component.
- We remove {3} and add Pre({3}) = {} to the strict component.
- We remove {2} and add Pre({2}) = {} to the strict component.
- We remove {1} and add Pre({1}) = {40,17} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, mult#1^#(nil(), @l2) -> #abs^#(#0())
, makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, matrixMultOld^#(@m1, @m2) ->
c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m))
, mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
, mult#2^#(nil(), @x, @xs) -> #abs^#(#0())
, split^#(@m) -> split#1^#(@m)
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
, transpose'^#(@m) ->
c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ #abs^#(#0()) -> c_1()
, #abs^#(#neg(@x)) -> c_2()
, #abs^#(#pos(@x)) -> c_3()
, #abs^#(#s(@x)) -> c_4()
, *^#(@x, @y) -> #mult^#(@x, @y)
, #mult^#(#0(), #0()) -> c_51()
, #mult^#(#0(), #neg(@y)) -> c_52()
, #mult^#(#0(), #pos(@y)) -> c_53()
, #mult^#(#neg(@x), #0()) -> c_54()
, #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y)
, #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y)
, #mult^#(#pos(@x), #0()) -> c_57()
, #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y)
, #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y)
, +^#(@x, @y) -> #add^#(@x, @y)
, #add^#(#0(), @y) -> c_60()
, #add^#(#neg(#s(#0())), @y) -> #pred^#(@y)
, #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, #add^#(#pos(#s(#0())), @y) -> #succ^#(@y)
, #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, attach#1^#(nil(), @m) -> c_9()
, attach#2^#(nil(), @x, @xs) -> c_11()
, lineMult#1^#(nil(), @l) -> c_14()
, makeBase#1^#(nil()) -> c_18()
, mkBase#1^#(nil()) -> c_32()
, transAcc#1^#(nil(), @base) -> c_44()
, matrixMult'#1^#(nil(), @m2) -> c_24()
, matrixMultList#1^#(nil(), @acc) -> c_28()
, transpose#1^#(nil(), @m) -> c_46()
, split#1^#(nil()) -> c_39()
, split#2^#(nil(), @ls) -> c_41()
, split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
, transpose#3^#(nil(), @l) -> c_49()
, #natmult^#(#0(), @y) -> c_73()
, #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y))
, #pred^#(#0()) -> c_65()
, #pred^#(#neg(#s(@x))) -> c_66()
, #pred^#(#pos(#s(#0()))) -> c_67()
, #pred^#(#pos(#s(#s(@x)))) -> c_68()
, #succ^#(#0()) -> c_69()
, #succ^#(#neg(#s(#0()))) -> c_70()
, #succ^#(#neg(#s(#s(@x)))) -> c_71()
, #succ^#(#pos(#s(@x))) -> c_72() }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :2
-->_1 attach#1^#(nil(), @m) -> c_9() :52
2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :3
-->_1 attach#2^#(nil(), @x, @xs) -> c_11() :53
3: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
4: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) :5
-->_1 lineMult#1^#(nil(), @l) -> c_14() :54
5: lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :6
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :4
6: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(nil(), @l2) -> #abs^#(#0()) :8
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :7
7: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(nil(), @x, @xs) -> #abs^#(#0()) :25
-->_1 mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)),
*^#(@x, @y),
mult^#(@xs, @ys)) :24
8: mult#1^#(nil(), @l2) -> #abs^#(#0())
-->_1 #abs^#(#0()) -> c_1() :32
9: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :10
-->_1 makeBase#1^#(nil()) -> c_18() :55
10: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :11
11: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :12
-->_1 mkBase#1^#(nil()) -> c_32() :56
12: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :11
13: matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :15
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :14
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :9
14: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :17
-->_1 matrixMult'#1^#(nil(), @m2) -> c_24() :58
15: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)),
transAcc^#(@m', @base)) :16
-->_1 transAcc#1^#(nil(), @base) -> c_44() :57
16: transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :15
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
17: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :14
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :4
18: matrixMult3^#(@m1, @m2, @m3) ->
c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :13
-->_1 matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :13
19: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :20
-->_1 matrixMultList#1^#(nil(), @acc) -> c_28() :59
20: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :19
-->_2 matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :13
21: matrixMultOld^#(@m1, @m2) ->
c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_2 transpose^#(@m) -> transpose#1^#(@m, @m) :22
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :14
22: transpose^#(@m) -> transpose#1^#(@m, @m)
-->_1 transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m)) :23
-->_1 transpose#1^#(nil(), @m) -> c_46() :60
23: transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m))
-->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :29
-->_2 split^#(@m) -> split#1^#(@m) :26
24: mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
-->_1 +^#(@x, @y) -> #add^#(@x, @y) :46
-->_2 *^#(@x, @y) -> #mult^#(@x, @y) :36
-->_3 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :6
25: mult#2^#(nil(), @x, @xs) -> #abs^#(#0())
-->_1 #abs^#(#0()) -> c_1() :32
26: split^#(@m) -> split#1^#(@m)
-->_1 split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) :27
-->_1 split#1^#(nil()) -> c_39() :61
27: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
-->_1 split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) :28
-->_1 split#2^#(nil(), @ls) -> c_41() :62
28: split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
-->_1 split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() :63
-->_2 split^#(@m) -> split#1^#(@m) :26
29: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
-->_1 transpose#3^#(::(@y, @ys), @l) ->
transpose^#(::(@y, @ys)) :30
-->_1 transpose#3^#(nil(), @l) -> c_49() :64
30: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :22
31: transpose'^#(@m) ->
c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_1 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :15
-->_2 makeBase^#(@m) -> makeBase#1^#(@m) :9
32: #abs^#(#0()) -> c_1()
33: #abs^#(#neg(@x)) -> c_2()
34: #abs^#(#pos(@x)) -> c_3()
35: #abs^#(#s(@x)) -> c_4()
36: *^#(@x, @y) -> #mult^#(@x, @y)
-->_1 #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y) :45
-->_1 #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y) :44
-->_1 #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y) :42
-->_1 #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y) :41
-->_1 #mult^#(#pos(@x), #0()) -> c_57() :43
-->_1 #mult^#(#neg(@x), #0()) -> c_54() :40
-->_1 #mult^#(#0(), #pos(@y)) -> c_53() :39
-->_1 #mult^#(#0(), #neg(@y)) -> c_52() :38
-->_1 #mult^#(#0(), #0()) -> c_51() :37
37: #mult^#(#0(), #0()) -> c_51()
38: #mult^#(#0(), #neg(@y)) -> c_52()
39: #mult^#(#0(), #pos(@y)) -> c_53()
40: #mult^#(#neg(@x), #0()) -> c_54()
41: #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y)
-->_1 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_1 #natmult^#(#0(), @y) -> c_73() :65
42: #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y)
-->_1 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_1 #natmult^#(#0(), @y) -> c_73() :65
43: #mult^#(#pos(@x), #0()) -> c_57()
44: #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y)
-->_1 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_1 #natmult^#(#0(), @y) -> c_73() :65
45: #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y)
-->_1 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_1 #natmult^#(#0(), @y) -> c_73() :65
46: +^#(@x, @y) -> #add^#(@x, @y)
-->_1 #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :51
-->_1 #add^#(#pos(#s(#0())), @y) -> #succ^#(@y) :50
-->_1 #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :49
-->_1 #add^#(#neg(#s(#0())), @y) -> #pred^#(@y) :48
-->_1 #add^#(#0(), @y) -> c_60() :47
47: #add^#(#0(), @y) -> c_60()
48: #add^#(#neg(#s(#0())), @y) -> #pred^#(@y)
-->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70
-->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69
-->_1 #pred^#(#neg(#s(@x))) -> c_66() :68
-->_1 #pred^#(#0()) -> c_65() :67
49: #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
-->_2 #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :51
-->_2 #add^#(#pos(#s(#0())), @y) -> #succ^#(@y) :50
-->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70
-->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69
-->_1 #pred^#(#neg(#s(@x))) -> c_66() :68
-->_1 #pred^#(#0()) -> c_65() :67
50: #add^#(#pos(#s(#0())), @y) -> #succ^#(@y)
-->_1 #succ^#(#pos(#s(@x))) -> c_72() :74
-->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73
-->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72
-->_1 #succ^#(#0()) -> c_69() :71
51: #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
-->_1 #succ^#(#pos(#s(@x))) -> c_72() :74
-->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73
-->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72
-->_1 #succ^#(#0()) -> c_69() :71
-->_2 #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :51
-->_2 #add^#(#pos(#s(#0())), @y) -> #succ^#(@y) :50
52: attach#1^#(nil(), @m) -> c_9()
53: attach#2^#(nil(), @x, @xs) -> c_11()
54: lineMult#1^#(nil(), @l) -> c_14()
55: makeBase#1^#(nil()) -> c_18()
56: mkBase#1^#(nil()) -> c_32()
57: transAcc#1^#(nil(), @base) -> c_44()
58: matrixMult'#1^#(nil(), @m2) -> c_24()
59: matrixMultList#1^#(nil(), @acc) -> c_28()
60: transpose#1^#(nil(), @m) -> c_46()
61: split#1^#(nil()) -> c_39()
62: split#2^#(nil(), @ls) -> c_41()
63: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
64: transpose#3^#(nil(), @l) -> c_49()
65: #natmult^#(#0(), @y) -> c_73()
66: #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y))
-->_2 #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y)) :66
-->_2 #natmult^#(#0(), @y) -> c_73() :65
-->_1 #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :51
-->_1 #add^#(#pos(#s(#0())), @y) -> #succ^#(@y) :50
67: #pred^#(#0()) -> c_65()
68: #pred^#(#neg(#s(@x))) -> c_66()
69: #pred^#(#pos(#s(#0()))) -> c_67()
70: #pred^#(#pos(#s(#s(@x)))) -> c_68()
71: #succ^#(#0()) -> c_69()
72: #succ^#(#neg(#s(#0()))) -> c_70()
73: #succ^#(#neg(#s(#s(@x)))) -> c_71()
74: #succ^#(#pos(#s(@x))) -> c_72()
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {25} and add Pre({25}) = {7} to the strict component.
- We remove {8} and add Pre({8}) = {6} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, matrixMultOld^#(@m1, @m2) ->
c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m))
, mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
, split^#(@m) -> split#1^#(@m)
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
, transpose'^#(@m) ->
c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ #abs^#(#0()) -> c_1()
, #abs^#(#neg(@x)) -> c_2()
, #abs^#(#pos(@x)) -> c_3()
, #abs^#(#s(@x)) -> c_4()
, *^#(@x, @y) -> #mult^#(@x, @y)
, #mult^#(#0(), #0()) -> c_51()
, #mult^#(#0(), #neg(@y)) -> c_52()
, #mult^#(#0(), #pos(@y)) -> c_53()
, #mult^#(#neg(@x), #0()) -> c_54()
, #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y)
, #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y)
, #mult^#(#pos(@x), #0()) -> c_57()
, #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y)
, #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y)
, +^#(@x, @y) -> #add^#(@x, @y)
, #add^#(#0(), @y) -> c_60()
, #add^#(#neg(#s(#0())), @y) -> #pred^#(@y)
, #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, #add^#(#pos(#s(#0())), @y) -> #succ^#(@y)
, #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, attach#1^#(nil(), @m) -> c_9()
, attach#2^#(nil(), @x, @xs) -> c_11()
, lineMult#1^#(nil(), @l) -> c_14()
, mult#1^#(nil(), @l2) -> #abs^#(#0())
, makeBase#1^#(nil()) -> c_18()
, mkBase#1^#(nil()) -> c_32()
, transAcc#1^#(nil(), @base) -> c_44()
, matrixMult'#1^#(nil(), @m2) -> c_24()
, matrixMultList#1^#(nil(), @acc) -> c_28()
, transpose#1^#(nil(), @m) -> c_46()
, mult#2^#(nil(), @x, @xs) -> #abs^#(#0())
, split#1^#(nil()) -> c_39()
, split#2^#(nil(), @ls) -> c_41()
, split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
, transpose#3^#(nil(), @l) -> c_49()
, #natmult^#(#0(), @y) -> c_73()
, #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y))
, #pred^#(#0()) -> c_65()
, #pred^#(#neg(#s(@x))) -> c_66()
, #pred^#(#pos(#s(#0()))) -> c_67()
, #pred^#(#pos(#s(#s(@x)))) -> c_68()
, #succ^#(#0()) -> c_69()
, #succ^#(#neg(#s(#0()))) -> c_70()
, #succ^#(#neg(#s(#s(@x)))) -> c_71()
, #succ^#(#pos(#s(@x))) -> c_72() }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the the dependency graph
->15:{17}
|
`->16:{12}
|
|->21:{8}
| |
| |->23:{9}
| | |
| | `->24:{10,11}
| | |
| | `->25:{55} Weak SCC
| |
| `->22:{54} Weak SCC
|
|->17:{13,16}
| |
| |->26:{4,5}
| | |
| | |->28:{6,23,7}
| | | |
| | | |->29:{34} Weak SCC
| | | | |
| | | | |->30:{35} Weak SCC
| | | | |
| | | | |->31:{36} Weak SCC
| | | | |
| | | | |->32:{37} Weak SCC
| | | | |
| | | | |->33:{38} Weak SCC
| | | | |
| | | | |->35:{39} Weak SCC
| | | | | |
| | | | | |->40:{65} Weak SCC
| | | | | |
| | | | | `->39:{66} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | |->49:{49} Weak SCC
| | | | | | |
| | | | | | |->50:{48}
Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | `->40:{65} Weak SCC
| | | | |
| | | | |->36:{40} Weak SCC
| | | | | |
| | | | | |->40:{65} Weak SCC
| | | | | |
| | | | | `->39:{66} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | |->49:{49} Weak SCC
| | | | | | |
| | | | | | |->50:{48}
Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | `->40:{65} Weak SCC
| | | | |
| | | | |->34:{41} Weak SCC
| | | | |
| | | | |->37:{42} Weak SCC
| | | | | |
| | | | | |->40:{65} Weak SCC
| | | | | |
| | | | | `->39:{66} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | |->49:{49} Weak SCC
| | | | | | |
| | | | | | |->50:{48}
Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | `->40:{65} Weak SCC
| | | | |
| | | | `->38:{43} Weak SCC
| | | | |
| | | | |->40:{65} Weak SCC
| | | | |
| | | | `->39:{66} Weak SCC
| | | | |
| | | | |->50:{48} Weak SCC
| | | | | |
| | | | | |->51:{71}
Weak SCC
| | | | | |
| | | | | |->52:{72}
Weak SCC
| | | | | |
| | | | | |->53:{73}
Weak SCC
| | | | | |
| | | | | `->54:{74}
Weak SCC
| | | | |
| | | | |->49:{49} Weak SCC
| | | | | |
| | | | | |->50:{48}
Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | |->51:{71}
Weak SCC
| | | | | |
| | | | | |->52:{72}
Weak SCC
| | | | | |
| | | | | |->53:{73}
Weak SCC
| | | | | |
| | | | | `->54:{74}
Weak SCC
| | | | |
| | | | `->40:{65} Weak SCC
| | | |
| | | |->41:{44} Weak SCC
| | | | |
| | | | |->42:{45} Weak SCC
| | | | |
| | | | |->43:{46} Weak SCC
| | | | | |
| | | | | |->45:{67} Weak SCC
| | | | | |
| | | | | |->46:{68} Weak SCC
| | | | | |
| | | | | |->47:{69} Weak SCC
| | | | | |
| | | | | `->48:{70} Weak SCC
| | | | |
| | | | |->44:{47} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | |->49:{49} Weak SCC
| | | | | | |
| | | | | | |->50:{48} Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | |->45:{67} Weak SCC
| | | | | |
| | | | | |->46:{68} Weak SCC
| | | | | |
| | | | | |->47:{69} Weak SCC
| | | | | |
| | | | | `->48:{70} Weak SCC
| | | | |
| | | | |->50:{48} Weak SCC
| | | | | |
| | | | | |->51:{71} Weak SCC
| | | | | |
| | | | | |->52:{72} Weak SCC
| | | | | |
| | | | | |->53:{73} Weak SCC
| | | | | |
| | | | | `->54:{74} Weak SCC
| | | | |
| | | | `->49:{49} Weak SCC
| | | | |
| | | | |->50:{48} Weak SCC
| | | | | |
| | | | | |->51:{71} Weak SCC
| | | | | |
| | | | | |->52:{72} Weak SCC
| | | | | |
| | | | | |->53:{73} Weak SCC
| | | | | |
| | | | | `->54:{74} Weak SCC
| | | | |
| | | | |->51:{71} Weak SCC
| | | | |
| | | | |->52:{72} Weak SCC
| | | | |
| | | | |->53:{73} Weak SCC
| | | | |
| | | | `->54:{74} Weak SCC
| | | |
| | | |->56:{53} Weak SCC
| | | | |
| | | | `->57:{30} Weak SCC
| | | |
| | | `->55:{60} Weak SCC
| | | |
| | | `->57:{30} Weak SCC
| | |
| | `->27:{52} Weak SCC
| |
| `->18:{57} Weak SCC
|
`->19:{14,15}
|
|->58:{1,3,2}
| |
| |->59:{50} Weak SCC
| |
| `->60:{51} Weak SCC
|
`->20:{56} Weak SCC
->13:{18,19}
|
|->16:{12}
| |
| |->21:{8}
| | |
| | |->23:{9}
| | | |
| | | `->24:{10,11}
| | | |
| | | `->25:{55} Weak SCC
| | |
| | `->22:{54} Weak SCC
| |
| |->17:{13,16}
| | |
| | |->26:{4,5}
| | | |
| | | |->28:{6,23,7}
| | | | |
| | | | |->29:{34} Weak SCC
| | | | | |
| | | | | |->30:{35} Weak SCC
| | | | | |
| | | | | |->31:{36} Weak SCC
| | | | | |
| | | | | |->32:{37} Weak SCC
| | | | | |
| | | | | |->33:{38} Weak SCC
| | | | | |
| | | | | |->35:{39} Weak SCC
| | | | | | |
| | | | | | |->40:{65} Weak SCC
| | | | | | |
| | | | | | `->39:{66} Weak SCC
| | | | | | |
| | | | | | |->50:{48} Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->49:{49} Weak SCC
| | | | | | | |
| | | | | | | |->50:{48}
Weak SCC
| | | | | | | | |
| | | | | | | | |->51:{71}
Weak SCC
| | | | | | | | |
| | | | | | | | |->52:{72}
Weak SCC
| | | | | | | | |
| | | | | | | | |->53:{73}
Weak SCC
| | | | | | | | |
| | | | | | | | `->54:{74}
Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | `->40:{65} Weak SCC
| | | | | |
| | | | | |->36:{40} Weak SCC
| | | | | | |
| | | | | | |->40:{65} Weak SCC
| | | | | | |
| | | | | | `->39:{66} Weak SCC
| | | | | | |
| | | | | | |->50:{48} Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->49:{49} Weak SCC
| | | | | | | |
| | | | | | | |->50:{48}
Weak SCC
| | | | | | | | |
| | | | | | | | |->51:{71}
Weak SCC
| | | | | | | | |
| | | | | | | | |->52:{72}
Weak SCC
| | | | | | | | |
| | | | | | | | |->53:{73}
Weak SCC
| | | | | | | | |
| | | | | | | | `->54:{74}
Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | `->40:{65} Weak SCC
| | | | | |
| | | | | |->34:{41} Weak SCC
| | | | | |
| | | | | |->37:{42} Weak SCC
| | | | | | |
| | | | | | |->40:{65} Weak SCC
| | | | | | |
| | | | | | `->39:{66} Weak SCC
| | | | | | |
| | | | | | |->50:{48} Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->49:{49} Weak SCC
| | | | | | | |
| | | | | | | |->50:{48}
Weak SCC
| | | | | | | | |
| | | | | | | | |->51:{71}
Weak SCC
| | | | | | | | |
| | | | | | | | |->52:{72}
Weak SCC
| | | | | | | | |
| | | | | | | | |->53:{73}
Weak SCC
| | | | | | | | |
| | | | | | | | `->54:{74}
Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | `->40:{65} Weak SCC
| | | | | |
| | | | | `->38:{43} Weak SCC
| | | | | |
| | | | | |->40:{65} Weak SCC
| | | | | |
| | | | | `->39:{66} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | |->49:{49} Weak SCC
| | | | | | |
| | | | | | |->50:{48}
Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | `->40:{65} Weak SCC
| | | | |
| | | | |->41:{44} Weak SCC
| | | | | |
| | | | | |->42:{45} Weak SCC
| | | | | |
| | | | | |->43:{46} Weak SCC
| | | | | | |
| | | | | | |->45:{67} Weak SCC
| | | | | | |
| | | | | | |->46:{68} Weak SCC
| | | | | | |
| | | | | | |->47:{69} Weak SCC
| | | | | | |
| | | | | | `->48:{70} Weak SCC
| | | | | |
| | | | | |->44:{47} Weak SCC
| | | | | | |
| | | | | | |->50:{48} Weak SCC
| | | | | | | |
| | | | | | | |->51:{71} Weak SCC
| | | | | | | |
| | | | | | | |->52:{72} Weak SCC
| | | | | | | |
| | | | | | | |->53:{73} Weak SCC
| | | | | | | |
| | | | | | | `->54:{74} Weak SCC
| | | | | | |
| | | | | | |->49:{49} Weak SCC
| | | | | | | |
| | | | | | | |->50:{48} Weak SCC
| | | | | | | | |
| | | | | | | | |->51:{71}
Weak SCC
| | | | | | | | |
| | | | | | | | |->52:{72}
Weak SCC
| | | | | | | | |
| | | | | | | | |->53:{73}
Weak SCC
| | | | | | | | |
| | | | | | | | `->54:{74}
Weak SCC
| | | | | | | |
| | | | | | | |->51:{71} Weak SCC
| | | | | | | |
| | | | | | | |->52:{72} Weak SCC
| | | | | | | |
| | | | | | | |->53:{73} Weak SCC
| | | | | | | |
| | | | | | | `->54:{74} Weak SCC
| | | | | | |
| | | | | | |->45:{67} Weak SCC
| | | | | | |
| | | | | | |->46:{68} Weak SCC
| | | | | | |
| | | | | | |->47:{69} Weak SCC
| | | | | | |
| | | | | | `->48:{70} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | `->49:{49} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | |->51:{71} Weak SCC
| | | | | |
| | | | | |->52:{72} Weak SCC
| | | | | |
| | | | | |->53:{73} Weak SCC
| | | | | |
| | | | | `->54:{74} Weak SCC
| | | | |
| | | | |->56:{53} Weak SCC
| | | | | |
| | | | | `->57:{30} Weak SCC
| | | | |
| | | | `->55:{60} Weak SCC
| | | | |
| | | | `->57:{30} Weak SCC
| | | |
| | | `->27:{52} Weak SCC
| | |
| | `->18:{57} Weak SCC
| |
| `->19:{14,15}
| |
| |->58:{1,3,2}
| | |
| | |->59:{50} Weak SCC
| | |
| | `->60:{51} Weak SCC
| |
| `->20:{56} Weak SCC
|
`->14:{58} Weak SCC
->5:{20}
|
|->17:{13,16}
| |
| |->26:{4,5}
| | |
| | |->28:{6,23,7}
| | | |
| | | |->29:{34} Weak SCC
| | | | |
| | | | |->30:{35} Weak SCC
| | | | |
| | | | |->31:{36} Weak SCC
| | | | |
| | | | |->32:{37} Weak SCC
| | | | |
| | | | |->33:{38} Weak SCC
| | | | |
| | | | |->35:{39} Weak SCC
| | | | | |
| | | | | |->40:{65} Weak SCC
| | | | | |
| | | | | `->39:{66} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | |->49:{49} Weak SCC
| | | | | | |
| | | | | | |->50:{48} Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | `->40:{65} Weak SCC
| | | | |
| | | | |->36:{40} Weak SCC
| | | | | |
| | | | | |->40:{65} Weak SCC
| | | | | |
| | | | | `->39:{66} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | |->49:{49} Weak SCC
| | | | | | |
| | | | | | |->50:{48} Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | `->40:{65} Weak SCC
| | | | |
| | | | |->34:{41} Weak SCC
| | | | |
| | | | |->37:{42} Weak SCC
| | | | | |
| | | | | |->40:{65} Weak SCC
| | | | | |
| | | | | `->39:{66} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | |->49:{49} Weak SCC
| | | | | | |
| | | | | | |->50:{48} Weak SCC
| | | | | | | |
| | | | | | | |->51:{71}
Weak SCC
| | | | | | | |
| | | | | | | |->52:{72}
Weak SCC
| | | | | | | |
| | | | | | | |->53:{73}
Weak SCC
| | | | | | | |
| | | | | | | `->54:{74}
Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | `->40:{65} Weak SCC
| | | | |
| | | | `->38:{43} Weak SCC
| | | | |
| | | | |->40:{65} Weak SCC
| | | | |
| | | | `->39:{66} Weak SCC
| | | | |
| | | | |->50:{48} Weak SCC
| | | | | |
| | | | | |->51:{71} Weak SCC
| | | | | |
| | | | | |->52:{72} Weak SCC
| | | | | |
| | | | | |->53:{73} Weak SCC
| | | | | |
| | | | | `->54:{74} Weak SCC
| | | | |
| | | | |->49:{49} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71}
Weak SCC
| | | | | | |
| | | | | | |->52:{72}
Weak SCC
| | | | | | |
| | | | | | |->53:{73}
Weak SCC
| | | | | | |
| | | | | | `->54:{74}
Weak SCC
| | | | | |
| | | | | |->51:{71} Weak SCC
| | | | | |
| | | | | |->52:{72} Weak SCC
| | | | | |
| | | | | |->53:{73} Weak SCC
| | | | | |
| | | | | `->54:{74} Weak SCC
| | | | |
| | | | `->40:{65} Weak SCC
| | | |
| | | |->41:{44} Weak SCC
| | | | |
| | | | |->42:{45} Weak SCC
| | | | |
| | | | |->43:{46} Weak SCC
| | | | | |
| | | | | |->45:{67} Weak SCC
| | | | | |
| | | | | |->46:{68} Weak SCC
| | | | | |
| | | | | |->47:{69} Weak SCC
| | | | | |
| | | | | `->48:{70} Weak SCC
| | | | |
| | | | |->44:{47} Weak SCC
| | | | | |
| | | | | |->50:{48} Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | |->49:{49} Weak SCC
| | | | | | |
| | | | | | |->50:{48} Weak SCC
| | | | | | | |
| | | | | | | |->51:{71} Weak SCC
| | | | | | | |
| | | | | | | |->52:{72} Weak SCC
| | | | | | | |
| | | | | | | |->53:{73} Weak SCC
| | | | | | | |
| | | | | | | `->54:{74} Weak SCC
| | | | | | |
| | | | | | |->51:{71} Weak SCC
| | | | | | |
| | | | | | |->52:{72} Weak SCC
| | | | | | |
| | | | | | |->53:{73} Weak SCC
| | | | | | |
| | | | | | `->54:{74} Weak SCC
| | | | | |
| | | | | |->45:{67} Weak SCC
| | | | | |
| | | | | |->46:{68} Weak SCC
| | | | | |
| | | | | |->47:{69} Weak SCC
| | | | | |
| | | | | `->48:{70} Weak SCC
| | | | |
| | | | |->50:{48} Weak SCC
| | | | | |
| | | | | |->51:{71} Weak SCC
| | | | | |
| | | | | |->52:{72} Weak SCC
| | | | | |
| | | | | |->53:{73} Weak SCC
| | | | | |
| | | | | `->54:{74} Weak SCC
| | | | |
| | | | `->49:{49} Weak SCC
| | | | |
| | | | |->50:{48} Weak SCC
| | | | | |
| | | | | |->51:{71} Weak SCC
| | | | | |
| | | | | |->52:{72} Weak SCC
| | | | | |
| | | | | |->53:{73} Weak SCC
| | | | | |
| | | | | `->54:{74} Weak SCC
| | | | |
| | | | |->51:{71} Weak SCC
| | | | |
| | | | |->52:{72} Weak SCC
| | | | |
| | | | |->53:{73} Weak SCC
| | | | |
| | | | `->54:{74} Weak SCC
| | | |
| | | |->56:{53} Weak SCC
| | | | |
| | | | `->57:{30} Weak SCC
| | | |
| | | `->55:{60} Weak SCC
| | | |
| | | `->57:{30} Weak SCC
| | |
| | `->27:{52} Weak SCC
| |
| `->18:{57} Weak SCC
|
`->6:{21,28,27,22}
|
|->8:{24,26,25}
| |
| |->9:{61} Weak SCC
| |
| |->10:{62} Weak SCC
| |
| `->11:{63} Weak SCC
|
|->7:{59} Weak SCC
|
`->12:{64} Weak SCC
->4:{29}
|
|->21:{8}
| |
| |->23:{9}
| | |
| | `->24:{10,11}
| | |
| | `->25:{55} Weak SCC
| |
| `->22:{54} Weak SCC
|
`->19:{14,15}
|
|->58:{1,3,2}
| |
| |->59:{50} Weak SCC
| |
| `->60:{51} Weak SCC
|
`->20:{56} Weak SCC
->3:{31} Weak SCC
->2:{32} Weak SCC
->1:{33} Weak SCC
Here dependency-pairs are as follows:
Strict DPs:
{ 1: attach^#(@line, @m) -> attach#1^#(@line, @m)
, 2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, 3: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, 4: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, 5: lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
, 6: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, 7: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, 8: makeBase^#(@m) -> makeBase#1^#(@m)
, 9: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, 10: mkBase^#(@m) -> mkBase#1^#(@m)
, 11: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, 12: matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, 13: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, 14: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, 15: transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, 16: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, 17: matrixMult3^#(@m1, @m2, @m3) ->
c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, 18: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, 19: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, 20: matrixMultOld^#(@m1, @m2) ->
c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, 21: transpose^#(@m) -> transpose#1^#(@m, @m)
, 22: transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m))
, 23: mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
, 24: split^#(@m) -> split#1^#(@m)
, 25: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, 26: split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
, 27: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, 28: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
, 29: transpose'^#(@m) ->
c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ 30: #abs^#(#0()) -> c_1()
, 31: #abs^#(#neg(@x)) -> c_2()
, 32: #abs^#(#pos(@x)) -> c_3()
, 33: #abs^#(#s(@x)) -> c_4()
, 34: *^#(@x, @y) -> #mult^#(@x, @y)
, 35: #mult^#(#0(), #0()) -> c_51()
, 36: #mult^#(#0(), #neg(@y)) -> c_52()
, 37: #mult^#(#0(), #pos(@y)) -> c_53()
, 38: #mult^#(#neg(@x), #0()) -> c_54()
, 39: #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y)
, 40: #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y)
, 41: #mult^#(#pos(@x), #0()) -> c_57()
, 42: #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y)
, 43: #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y)
, 44: +^#(@x, @y) -> #add^#(@x, @y)
, 45: #add^#(#0(), @y) -> c_60()
, 46: #add^#(#neg(#s(#0())), @y) -> #pred^#(@y)
, 47: #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, 48: #add^#(#pos(#s(#0())), @y) -> #succ^#(@y)
, 49: #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, 50: attach#1^#(nil(), @m) -> c_9()
, 51: attach#2^#(nil(), @x, @xs) -> c_11()
, 52: lineMult#1^#(nil(), @l) -> c_14()
, 53: mult#1^#(nil(), @l2) -> #abs^#(#0())
, 54: makeBase#1^#(nil()) -> c_18()
, 55: mkBase#1^#(nil()) -> c_32()
, 56: transAcc#1^#(nil(), @base) -> c_44()
, 57: matrixMult'#1^#(nil(), @m2) -> c_24()
, 58: matrixMultList#1^#(nil(), @acc) -> c_28()
, 59: transpose#1^#(nil(), @m) -> c_46()
, 60: mult#2^#(nil(), @x, @xs) -> #abs^#(#0())
, 61: split#1^#(nil()) -> c_39()
, 62: split#2^#(nil(), @ls) -> c_41()
, 63: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
, 64: transpose#3^#(nil(), @l) -> c_49()
, 65: #natmult^#(#0(), @y) -> c_73()
, 66: #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y))
, 67: #pred^#(#0()) -> c_65()
, 68: #pred^#(#neg(#s(@x))) -> c_66()
, 69: #pred^#(#pos(#s(#0()))) -> c_67()
, 70: #pred^#(#pos(#s(#s(@x)))) -> c_68()
, 71: #succ^#(#0()) -> c_69()
, 72: #succ^#(#neg(#s(#0()))) -> c_70()
, 73: #succ^#(#neg(#s(#s(@x)))) -> c_71()
, 74: #succ^#(#pos(#s(@x))) -> c_72() }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 33: #abs^#(#s(@x)) -> c_4()
, 32: #abs^#(#pos(@x)) -> c_3()
, 31: #abs^#(#neg(@x)) -> c_2()
, 59: transpose#1^#(nil(), @m) -> c_46()
, 61: split#1^#(nil()) -> c_39()
, 62: split#2^#(nil(), @ls) -> c_41()
, 63: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
, 64: transpose#3^#(nil(), @l) -> c_49()
, 58: matrixMultList#1^#(nil(), @acc) -> c_28()
, 57: matrixMult'#1^#(nil(), @m2) -> c_24()
, 56: transAcc#1^#(nil(), @base) -> c_44()
, 54: makeBase#1^#(nil()) -> c_18()
, 55: mkBase#1^#(nil()) -> c_32()
, 52: lineMult#1^#(nil(), @l) -> c_14()
, 34: *^#(@x, @y) -> #mult^#(@x, @y)
, 35: #mult^#(#0(), #0()) -> c_51()
, 36: #mult^#(#0(), #neg(@y)) -> c_52()
, 37: #mult^#(#0(), #pos(@y)) -> c_53()
, 38: #mult^#(#neg(@x), #0()) -> c_54()
, 41: #mult^#(#pos(@x), #0()) -> c_57()
, 39: #mult^#(#neg(@x), #neg(@y)) -> #natmult^#(@x, @y)
, 40: #mult^#(#neg(@x), #pos(@y)) -> #natmult^#(@x, @y)
, 42: #mult^#(#pos(@x), #neg(@y)) -> #natmult^#(@x, @y)
, 43: #mult^#(#pos(@x), #pos(@y)) -> #natmult^#(@x, @y)
, 66: #natmult^#(#s(@x), @y) ->
c_74(#add^#(#pos(@y), #natmult(@x, @y)), #natmult^#(@x, @y))
, 65: #natmult^#(#0(), @y) -> c_73()
, 44: +^#(@x, @y) -> #add^#(@x, @y)
, 45: #add^#(#0(), @y) -> c_60()
, 46: #add^#(#neg(#s(#0())), @y) -> #pred^#(@y)
, 47: #add^#(#neg(#s(#s(@x))), @y) ->
c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, 67: #pred^#(#0()) -> c_65()
, 68: #pred^#(#neg(#s(@x))) -> c_66()
, 69: #pred^#(#pos(#s(#0()))) -> c_67()
, 70: #pred^#(#pos(#s(#s(@x)))) -> c_68()
, 49: #add^#(#pos(#s(#s(@x))), @y) ->
c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, 48: #add^#(#pos(#s(#0())), @y) -> #succ^#(@y)
, 71: #succ^#(#0()) -> c_69()
, 72: #succ^#(#neg(#s(#0()))) -> c_70()
, 73: #succ^#(#neg(#s(#s(@x)))) -> c_71()
, 74: #succ^#(#pos(#s(@x))) -> c_72()
, 60: mult#2^#(nil(), @x, @xs) -> #abs^#(#0())
, 53: mult#1^#(nil(), @l2) -> #abs^#(#0())
, 30: #abs^#(#0()) -> c_1()
, 50: attach#1^#(nil(), @m) -> c_9()
, 51: attach#2^#(nil(), @x, @xs) -> c_11() }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, matrixMultOld^#(@m1, @m2) ->
c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m))
, mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
, split^#(@m) -> split#1^#(@m)
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
, transpose'^#(@m) ->
c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :2
2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :3
3: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
4: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) :5
5: lineMult#1^#(::(@x, @xs), @l) ->
c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :6
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :4
6: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :7
7: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)),
*^#(@x, @y),
mult^#(@xs, @ys)) :23
8: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :9
9: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :10
10: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :11
11: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :10
12: matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :14
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :13
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :8
13: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :16
14: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)),
transAcc^#(@m', @base)) :15
15: transAcc#1^#(::(@l, @m'), @base) ->
c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :14
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
16: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :13
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :4
17: matrixMult3^#(@m1, @m2, @m3) ->
c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :12
-->_1 matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :12
18: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :19
19: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :18
-->_2 matrixMult^#(@m1, @m2) ->
c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :12
20: matrixMultOld^#(@m1, @m2) ->
c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_2 transpose^#(@m) -> transpose#1^#(@m, @m) :21
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :13
21: transpose^#(@m) -> transpose#1^#(@m, @m)
-->_1 transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m)) :22
22: transpose#1^#(::(@xs, @xss), @m) ->
c_45(transpose#2^#(split(@m)), split^#(@m))
-->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :27
-->_2 split^#(@m) -> split#1^#(@m) :24
23: mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
-->_3 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :6
24: split^#(@m) -> split#1^#(@m)
-->_1 split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) :25
25: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
-->_1 split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) :26
26: split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
-->_2 split^#(@m) -> split#1^#(@m) :24
27: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
-->_1 transpose#3^#(::(@y, @ys), @l) ->
transpose^#(::(@y, @ys)) :28
28: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :21
29: transpose'^#(@m) ->
c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_1 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :14
-->_2 makeBase^#(@m) -> makeBase#1^#(@m) :8
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ mult#2^#(::(@y, @ys), @x, @xs) ->
c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
, split#2^#(::(@x, @xs), @ls) ->
c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
, split^#(@m) -> split#1^#(@m)
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We employ 'linear path analysis' using the following approximated
dependency graph:
->6:{17} [ ? ]
|
`->7:{12} [ ? ]
|
|->10:{8} [ ? ]
| |
| `->11:{9} [ ? ]
| |
| `->12:{10,11} [ MAYBE ]
|
|->8:{13,16} [ ? ]
| |
| `->13:{4,5} [ ? ]
| |
| `->14:{6,23,7} [ MAYBE ]
|
`->9:{14,15} [ ? ]
|
`->15:{1,3,2} [ MAYBE ]
->5:{18,19} [ ? ]
|
`->7:{12} [ ? ]
|
|->10:{8} [ ? ]
| |
| `->11:{9} [ ? ]
| |
| `->12:{10,11} [ MAYBE ]
|
|->8:{13,16} [ ? ]
| |
| `->13:{4,5} [ ? ]
| |
| `->14:{6,23,7} [ MAYBE ]
|
`->9:{14,15} [ ? ]
|
`->15:{1,3,2} [ MAYBE ]
->2:{20} [ ? ]
|
|->8:{13,16} [ ? ]
| |
| `->13:{4,5} [ ? ]
| |
| `->14:{6,23,7} [ MAYBE ]
|
`->3:{21,28,27,22} [ ? ]
|
`->4:{24,26,25} [ YES(O(1),O(n^1)) ]
->1:{29} [ ? ]
|
|->10:{8} [ ? ]
| |
| `->11:{9} [ ? ]
| |
| `->12:{10,11} [ YES(O(1),O(n^1)) ]
|
`->9:{14,15} [ ? ]
|
`->15:{1,3,2} [ YES(O(1),O(n^1)) ]
Here dependency-pairs are as follows:
Strict DPs:
{ 1: attach^#(@line, @m) -> attach#1^#(@line, @m)
, 2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, 3: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, 4: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, 5: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, 6: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, 7: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, 8: makeBase^#(@m) -> makeBase#1^#(@m)
, 9: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, 10: mkBase^#(@m) -> mkBase#1^#(@m)
, 11: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, 12: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, 13: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, 14: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, 15: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, 16: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, 17: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, 18: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, 19: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, 20: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, 21: transpose^#(@m) -> transpose#1^#(@m, @m)
, 22: transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
, 23: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
, 24: split^#(@m) -> split#1^#(@m)
, 25: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, 26: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, 27: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, 28: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
, 29: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
* Path 6:{17}->7:{12}->10:{8}->11:{9}->12:{10,11}: MAYBE
------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :2
2: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :3
3: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :4
4: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :3
5: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :1
6: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
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:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs: { mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :2
2: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :3
3: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :6
4: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :1
5: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :4
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :4
6: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :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:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :5
2: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :6
3: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :1
4: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
5: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :2
6: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {1} and add Pre({1}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :6
2: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :4
3: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :2
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :2
4: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :5
5: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
6: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {3,3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :5
2: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :6
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :6
3: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :4
4: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
5: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
6: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs: { mkBase^#(@m) -> mkBase#1^#(@m) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :4
2: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :3
3: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
4: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
5: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :2
6: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs: { mkBase^#(@m) -> mkBase#1^#(@m) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) -> makeBase^#(@m2)
, matrixMult3^#(@m1, @m2, @m3) ->
c_1(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs: { mkBase^#(@m) -> mkBase#1^#(@m) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) -> makeBase^#(@m2)
, matrixMult3^#(@m1, @m2, @m3) ->
c_1(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
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:
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 6:{17}->7:{12}->8:{13,16}->13:{4,5}->14:{6,23,7}: MAYBE
------------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
2: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
3: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :4
4: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :9
5: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :6
6: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :7
7: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :6
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
8: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
9: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {9} and add Pre({9}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs: { mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
2: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
3: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :4
4: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :9
5: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :6
6: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :7
7: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :6
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
8: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
9: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
2: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
3: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :8
4: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :5
5: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :6
6: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :5
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
7: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :4
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :4
8: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :9
9: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :7
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :8
3: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
4: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :5
5: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
6: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
7: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
8: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :9
9: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :6
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :7
3: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
4: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :8
5: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
6: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
7: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :9
8: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
9: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {5,5} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :5
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :6
3: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :8
4: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :7
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :7
5: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
6: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :9
7: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
8: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
9: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :4
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :5
3: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :7
4: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
5: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :9
6: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
7: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
8: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :6
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :6
9: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_2(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
c_3(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
No subproblems were checked.
* Path 6:{17}->7:{12}->9:{14,15}->15:{1,3,2}: MAYBE
-------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :2
2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :3
3: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
4: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :5
5: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :6
6: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :5
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
7: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :4
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :4
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^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :2
2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :7
3: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :4
4: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :5
5: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :4
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
6: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
7: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :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:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :6
2: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
3: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :4
4: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
5: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :2
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :2
6: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :7
7: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
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^#(@line, @m) -> attach#1^#(@line, @m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :5
2: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
3: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :7
4: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :2
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :2
5: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :6
6: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
7: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {4,4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :4
2: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :7
3: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :6
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :6
4: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :5
5: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
6: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
7: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :3
2: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :6
3: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :4
4: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
5: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
6: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
7: matrixMult3^#(@m1, @m2, @m3) ->
c_5(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
-->_1 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2))
, transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMult3^#(@m1, @m2, @m3) ->
c_2(matrixMult^#(matrixMult(@m1, @m2), @m3),
matrixMult^#(@m1, @m2)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
No subproblems were checked.
* Path 5:{18,19}->7:{12}->10:{8}->11:{9}->12:{10,11}: MAYBE
---------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :2
2: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :3
3: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :4
4: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :3
5: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :1
6: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :7
7: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :6
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
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:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs: { mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :2
2: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :3
3: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :7
4: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :1
5: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :6
6: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :5
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :4
7: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :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:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :6
2: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :7
3: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :1
4: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :5
5: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :4
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
6: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :2
7: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {1} and add Pre({1}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :7
2: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :5
3: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :4
4: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :3
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :2
5: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :6
6: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
7: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :6
2: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :3
3: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :7
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :2
4: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :5
5: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
6: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
7: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :4
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:
{ mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :5
2: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :7
3: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :4
4: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
5: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
6: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_3 makeBase^#(@m) -> makeBase#1^#(@m) :3
7: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :6
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ mkBase^#(@m) -> mkBase#1^#(@m)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, matrixMult^#(@m1, @m2) -> makeBase^#(@m2)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_1(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
No subproblems were checked.
* Path 5:{18,19}->7:{12}->8:{13,16}->13:{4,5}->14:{6,23,7}: MAYBE
---------------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
2: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
3: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :4
4: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :10
5: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :6
6: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :7
7: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :6
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
8: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :9
9: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :8
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
10: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {10} and add Pre({10}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs: { mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
2: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
3: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :4
4: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :10
5: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :6
6: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :7
7: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :6
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
8: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :9
9: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :8
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :5
10: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
2: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
3: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :9
4: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :5
5: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :6
6: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :5
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
7: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :8
8: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :7
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :4
9: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :10
10: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :8
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :9
3: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
4: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :5
5: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
6: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :7
7: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :6
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
8: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
9: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :10
10: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :7
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :8
3: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
4: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :9
5: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :6
6: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :5
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
7: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
8: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :10
9: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
10: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {6} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :6
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :7
3: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :9
4: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :5
5: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :8
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :4
6: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
7: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :10
8: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
9: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
10: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :5
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :6
3: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :8
4: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :9
5: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
6: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :10
7: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
8: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
9: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :7
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :4
10: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult^#(@m1, @m2) ->
matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_2(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_3(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
No subproblems were checked.
* Path 5:{18,19}->7:{12}->9:{14,15}->15:{1,3,2}: MAYBE
----------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :2
2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :3
3: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
4: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :5
5: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :6
6: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :5
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
7: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :8
8: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :7
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :4
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^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :2
2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :8
3: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :4
4: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :5
5: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :4
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
6: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :7
7: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :6
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :3
8: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :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:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :7
2: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
3: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :4
4: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
5: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :6
6: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :5
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :2
7: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :8
8: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
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^#(@line, @m) -> attach#1^#(@line, @m)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :6
2: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
3: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :8
4: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :5
5: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :4
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :2
6: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :7
7: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
8: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {5} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :5
2: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :8
3: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :4
4: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :7
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :3
5: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :6
6: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
7: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
8: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
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^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :4
2: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :7
3: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
-->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) :8
4: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :5
5: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
6: matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
7: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
8: matrixMultList#1^#(::(@m, @ms), @acc) ->
c_6(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m))
-->_2 matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) :6
-->_1 matrixMultList^#(@acc, @mm) ->
matrixMultList#1^#(@mm, @acc) :3
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ matrixMult^#(@m1, @m2) ->
c_2(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
transAcc^#(@m2, makeBase(@m2)),
makeBase^#(@m2)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2))
, transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, matrixMultList#1^#(::(@m, @ms), @acc) ->
c_2(matrixMultList^#(matrixMult(@acc, @m), @ms),
matrixMult^#(@acc, @m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
No subproblems were checked.
* Path 2:{20}->8:{13,16}->13:{4,5}->14:{6,23,7}: MAYBE
----------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
2: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
3: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :4
4: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :8
5: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :6
6: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :5
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
7: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :5
8: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {8} and add Pre({8}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }
Weak DPs: { mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
2: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
3: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :4
4: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :8
5: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :6
6: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :5
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
7: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :5
8: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }
Weak DPs:
{ mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
2: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :3
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
3: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :7
4: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :5
5: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
6: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :4
7: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :8
8: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :6
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :7
3: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :4
4: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
5: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
6: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
7: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :8
8: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :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:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :5
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :6
3: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :7
4: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
5: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
6: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :8
7: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
8: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
-->_1 lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs)) :4
2: mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
-->_1 mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs) :5
3: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
-->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :6
4: lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
-->_2 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
5: mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
-->_1 mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) :8
6: matrixMult'#1^#(::(@l, @ls), @m2) ->
c_4(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
-->_2 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
-->_1 lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) :1
7: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_1 matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) :3
8: mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys)
-->_1 mult^#(@l1, @l2) -> mult#1^#(@l1, @l2) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l)
, mult^#(@l1, @l2) -> mult#1^#(@l1, @l2)
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) }
Weak DPs:
{ lineMult#1^#(::(@x, @xs), @l) ->
c_1(mult^#(@l, @x), lineMult^#(@l, @xs))
, mult#1^#(::(@x, @xs), @l2) -> mult#2^#(@l2, @x, @xs)
, matrixMult'#1^#(::(@l, @ls), @m2) ->
c_2(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
, matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2))
, mult#2^#(::(@y, @ys), @x, @xs) -> mult^#(@xs, @ys) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ transpose(@m) -> transpose#1(@m, @m)
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil() }
No subproblems were checked.
* Path 2:{20}->3:{21,28,27,22}->4:{24,26,25}: YES(O(1),O(n^1))
------------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
, split^#(@m) -> split#1^#(@m)
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_2 transpose^#(@m) -> transpose#1^#(@m, @m) :2
2: transpose^#(@m) -> transpose#1^#(@m, @m)
-->_1 transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m)) :3
3: transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
-->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :7
-->_2 split^#(@m) -> split#1^#(@m) :4
4: split^#(@m) -> split#1^#(@m)
-->_1 split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) :5
5: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
-->_1 split#2^#(::(@x, @xs), @ls) -> split^#(@ls) :6
6: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
-->_1 split^#(@m) -> split#1^#(@m) :4
7: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
-->_1 transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) :8
8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :2
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 remove {8} and add Pre({8}) = {7} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
, split^#(@m) -> split#1^#(@m)
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) }
Weak DPs:
{ split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_2 transpose^#(@m) -> transpose#1^#(@m, @m) :2
2: transpose^#(@m) -> transpose#1^#(@m, @m)
-->_1 transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m)) :3
3: transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
-->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :6
-->_2 split^#(@m) -> split#1^#(@m) :4
4: split^#(@m) -> split#1^#(@m)
-->_1 split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) :5
5: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
-->_1 split#2^#(::(@x, @xs), @ls) -> split^#(@ls) :7
6: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
-->_1 transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) :8
7: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
-->_1 split^#(@m) -> split#1^#(@m) :4
8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :2
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 remove {6} and add Pre({6}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
, split^#(@m) -> split#1^#(@m) }
Weak DPs:
{ split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_2 transpose^#(@m) -> transpose#1^#(@m, @m) :2
2: transpose^#(@m) -> transpose#1^#(@m, @m)
-->_1 transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m)) :3
3: transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
-->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :7
-->_2 split^#(@m) -> split#1^#(@m) :4
4: split^#(@m) -> split#1^#(@m)
-->_1 split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) :5
5: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
-->_1 split#2^#(::(@x, @xs), @ls) -> split^#(@ls) :6
6: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
-->_1 split^#(@m) -> split#1^#(@m) :4
7: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
-->_1 transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) :8
8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :2
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^1)).
Strict DPs:
{ matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose^#(@m) -> transpose#1^#(@m, @m)
, split^#(@m) -> split#1^#(@m) }
Weak DPs:
{ transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_2 transpose^#(@m) -> transpose#1^#(@m, @m) :2
2: transpose^#(@m) -> transpose#1^#(@m, @m)
-->_1 transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m)) :4
3: split^#(@m) -> split#1^#(@m)
-->_1 split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) :5
4: transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
-->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :7
-->_2 split^#(@m) -> split#1^#(@m) :3
5: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
-->_1 split#2^#(::(@x, @xs), @ls) -> split^#(@ls) :6
6: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
-->_1 split^#(@m) -> split#1^#(@m) :3
7: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
-->_1 transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) :8
8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {1} and add Pre({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:
{ transpose^#(@m) -> transpose#1^#(@m, @m)
, split^#(@m) -> split#1^#(@m) }
Weak DPs:
{ matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
, transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: transpose^#(@m) -> transpose#1^#(@m, @m)
-->_1 transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m)) :4
2: split^#(@m) -> split#1^#(@m)
-->_1 split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) :5
3: matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
-->_2 transpose^#(@m) -> transpose#1^#(@m, @m) :1
4: transpose#1^#(::(@xs, @xss), @m) ->
c_8(transpose#2^#(split(@m)), split^#(@m))
-->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :7
-->_2 split^#(@m) -> split#1^#(@m) :2
5: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
-->_1 split#2^#(::(@x, @xs), @ls) -> split^#(@ls) :6
6: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
-->_1 split^#(@m) -> split#1^#(@m) :2
7: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
-->_1 transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) :8
8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ matrixMultOld^#(@m1, @m2) ->
c_7(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ transpose^#(@m) -> transpose#1^#(@m, @m)
, split^#(@m) -> split#1^#(@m) }
Weak DPs:
{ matrixMultOld^#(@m1, @m2) -> transpose^#(@m2)
, transpose#1^#(::(@xs, @xss), @m) ->
c_1(transpose#2^#(split(@m)), split^#(@m))
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m')) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ transpose^#(@m) -> transpose#1^#(@m, @m)
, split^#(@m) -> split#1^#(@m) }
Weak DPs:
{ matrixMultOld^#(@m1, @m2) -> transpose^#(@m2)
, transpose#1^#(::(@xs, @xss), @m) ->
c_1(transpose#2^#(split(@m)), split^#(@m))
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
Weak Trs:
{ split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m')) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.
DPs:
{ 5: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, 6: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, 8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
Trs:
{ split#1(nil()) -> tuple#2(nil(), nil())
, split#2(nil(), @ls) -> tuple#2(nil(), nil()) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#neg) = {}, Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(::) = {},
Uargs(split) = {}, Uargs(split#1) = {}, Uargs(split#2) = {},
Uargs(tuple#2) = {}, Uargs(split#3) = {}, Uargs(#abs^#) = {},
Uargs(*^#) = {}, Uargs(#mult^#) = {}, Uargs(+^#) = {},
Uargs(#add^#) = {}, Uargs(attach^#) = {}, Uargs(attach#1^#) = {},
Uargs(attach#2^#) = {}, Uargs(lineMult^#) = {},
Uargs(lineMult#1^#) = {}, Uargs(mult^#) = {}, Uargs(mult#1^#) = {},
Uargs(makeBase^#) = {}, Uargs(makeBase#1^#) = {},
Uargs(mkBase^#) = {}, Uargs(mkBase#1^#) = {},
Uargs(matrixMult^#) = {}, Uargs(matrixMult'^#) = {},
Uargs(transAcc^#) = {}, Uargs(transAcc#1^#) = {},
Uargs(matrixMult'#1^#) = {}, Uargs(matrixMult3^#) = {},
Uargs(matrixMultList^#) = {}, Uargs(matrixMultList#1^#) = {},
Uargs(matrixMultOld^#) = {}, Uargs(transpose^#) = {},
Uargs(transpose#1^#) = {}, Uargs(mult#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {}, Uargs(split#2^#) = {},
Uargs(split#3^#) = {}, Uargs(transpose#2^#) = {},
Uargs(transpose#3^#) = {}, Uargs(transpose'^#) = {},
Uargs(#natmult^#) = {}, Uargs(#pred^#) = {}, Uargs(#succ^#) = {},
Uargs(c_1) = {1, 2}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA) and not(IDA(1)).
[#0] = [0]
[0]
[#neg](x1) = [0 0] x1 + [0]
[1 1] [0]
[#pos](x1) = [0 1] x1 + [0]
[0 0] [0]
[#s](x1) = [1 1] x1 + [0]
[0 0] [0]
[::](x1, x2) = [1 1] x1 + [1 0] x2 + [3]
[0 0] [0 1] [2]
[nil] = [0]
[0]
[split](x1) = [0 0] x1 + [2]
[1 0] [1]
[split#1](x1) = [0 0] x1 + [2]
[1 0] [0]
[split#2](x1, x2) = [0 0] x1 + [0 0] x2 + [2]
[1 1] [1 0] [3]
[tuple#2](x1, x2) = [0 0] x2 + [1]
[1 1] [0]
[split#3](x1, x2, x3) = [1 0] x1 + [0 0] x3 + [0]
[2 1] [1 1] [3]
[#abs^#](x1) = [0]
[0]
[*^#](x1, x2) = [0]
[0]
[#mult^#](x1, x2) = [0]
[0]
[+^#](x1, x2) = [0]
[0]
[#add^#](x1, x2) = [0]
[0]
[attach^#](x1, x2) = [0]
[0]
[attach#1^#](x1, x2) = [0]
[0]
[attach#2^#](x1, x2, x3) = [0]
[0]
[lineMult^#](x1, x2) = [0]
[0]
[lineMult#1^#](x1, x2) = [0]
[0]
[mult^#](x1, x2) = [0]
[0]
[mult#1^#](x1, x2) = [0]
[0]
[makeBase^#](x1) = [0]
[0]
[makeBase#1^#](x1) = [0]
[0]
[mkBase^#](x1) = [0]
[0]
[mkBase#1^#](x1) = [0]
[0]
[matrixMult^#](x1, x2) = [0]
[0]
[matrixMult'^#](x1, x2) = [0]
[0]
[transAcc^#](x1, x2) = [0]
[0]
[transAcc#1^#](x1, x2) = [0]
[0]
[matrixMult'#1^#](x1, x2) = [0]
[0]
[matrixMult3^#](x1, x2, x3) = [0]
[0]
[matrixMultList^#](x1, x2) = [0]
[0]
[matrixMultList#1^#](x1, x2) = [0]
[0]
[matrixMultOld^#](x1, x2) = [3 3] x2 + [3]
[3 3] [3]
[transpose^#](x1) = [3 1] x1 + [3]
[0 0] [0]
[transpose#1^#](x1, x2) = [3 1] x2 + [3]
[0 0] [0]
[mult#2^#](x1, x2, x3) = [0]
[0]
[split^#](x1) = [0 1] x1 + [0]
[0 0] [1]
[split#1^#](x1) = [0 1] x1 + [0]
[0 0] [1]
[split#2^#](x1, x2) = [0 1] x2 + [1]
[0 0] [1]
[split#3^#](x1, x2, x3) = [0]
[0]
[transpose#2^#](x1) = [0 3] x1 + [0]
[0 0] [1]
[transpose#3^#](x1, x2) = [3 3] x1 + [0]
[0 0] [0]
[transpose'^#](x1) = [0]
[0]
[#natmult^#](x1, x2) = [0]
[0]
[#pred^#](x1) = [0]
[0]
[#succ^#](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
[split(@m)] = [0 0] @m + [2]
[1 0] [1]
>= [0 0] @m + [2]
[1 0] [0]
= [split#1(@m)]
[split#1(::(@l, @ls))] = [0 0] @l + [0 0] @ls + [2]
[1 1] [1 0] [3]
>= [0 0] @l + [0 0] @ls + [2]
[1 1] [1 0] [3]
= [split#2(@l, @ls)]
[split#1(nil())] = [2]
[0]
> [1]
[0]
= [tuple#2(nil(), nil())]
[split#2(::(@x, @xs), @ls)] = [0 0] @ls + [0 0] @x + [0 0] @xs + [2]
[1 0] [1 1] [1 1] [8]
>= [0 0] @ls + [0 0] @xs + [2]
[1 0] [1 1] [8]
= [split#3(split(@ls), @x, @xs)]
[split#2(nil(), @ls)] = [0 0] @ls + [2]
[1 0] [3]
> [1]
[0]
= [tuple#2(nil(), nil())]
[split#3(tuple#2(@ys, @m'), @x, @xs)] = [0 0] @m' + [0 0] @xs + [1]
[1 1] [1 1] [5]
>= [0 0] @m' + [0 0] @xs + [1]
[1 1] [1 1] [5]
= [tuple#2(::(@x, @ys), ::(@xs, @m'))]
[matrixMultOld^#(@m1, @m2)] = [3 3] @m2 + [3]
[3 3] [3]
>= [3 1] @m2 + [3]
[0 0] [0]
= [transpose^#(@m2)]
[transpose^#(@m)] = [3 1] @m + [3]
[0 0] [0]
>= [3 1] @m + [3]
[0 0] [0]
= [transpose#1^#(@m, @m)]
[transpose#1^#(::(@xs, @xss), @m)] = [3 1] @m + [3]
[0 0] [0]
>= [3 1] @m + [3]
[0 0] [0]
= [c_1(transpose#2^#(split(@m)), split^#(@m))]
[split^#(@m)] = [0 1] @m + [0]
[0 0] [1]
>= [0 1] @m + [0]
[0 0] [1]
= [split#1^#(@m)]
[split#1^#(::(@l, @ls))] = [0 1] @ls + [2]
[0 0] [1]
> [0 1] @ls + [1]
[0 0] [1]
= [split#2^#(@l, @ls)]
[split#2^#(::(@x, @xs), @ls)] = [0 1] @ls + [1]
[0 0] [1]
> [0 1] @ls + [0]
[0 0] [1]
= [split^#(@ls)]
[transpose#2^#(tuple#2(@l, @m'))] = [3 3] @m' + [0]
[0 0] [1]
>= [3 3] @m' + [0]
[0 0] [0]
= [transpose#3^#(@m', @l)]
[transpose#3^#(::(@y, @ys), @l)] = [3 3] @y + [3 3] @ys + [15]
[0 0] [0 0] [0]
> [3 3] @y + [3 1] @ys + [14]
[0 0] [0 0] [0]
= [transpose^#(::(@y, @ys))]
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{5,6,8}. Here rules are labeled according to the (estimated)
dependency graph
1: transpose^#(@m) -> transpose#1^#(@m, @m)
-->_1 transpose#1^#(::(@xs, @xss), @m) ->
c_1(transpose#2^#(split(@m)), split^#(@m)) :4
2: split^#(@m) -> split#1^#(@m)
-->_1 split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) :5
3: matrixMultOld^#(@m1, @m2) -> transpose^#(@m2)
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :1
4: transpose#1^#(::(@xs, @xss), @m) ->
c_1(transpose#2^#(split(@m)), split^#(@m))
-->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :7
-->_2 split^#(@m) -> split#1^#(@m) :2
5: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
-->_1 split#2^#(::(@x, @xs), @ls) -> split^#(@ls) :6
6: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
-->_1 split^#(@m) -> split#1^#(@m) :2
7: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
-->_1 transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) :8
8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
-->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :1
- The rules {5,6,8} have known complexity. These cover all
predecessors of {3}, their complexity is equally bounded.
- The rules {3,5,6,8} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
- The rules {1,3,5,6,8} have known complexity. These cover all
predecessors of {4}, their complexity is equally bounded.
- The rules {1,3,4,5,6,8} have known complexity. These cover all
predecessors of {2,7}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4,5,6,7,8} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ matrixMultOld^#(@m1, @m2) -> transpose^#(@m2)
, transpose^#(@m) -> transpose#1^#(@m, @m)
, transpose#1^#(::(@xs, @xss), @m) ->
c_1(transpose#2^#(split(@m)), split^#(@m))
, split^#(@m) -> split#1^#(@m)
, split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
Weak Trs:
{ split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m')) }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{1} Weak SCC
|
`->2:{2,8,7,3} Weak SCC
|
`->3:{4,6,5} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: matrixMultOld^#(@m1, @m2) -> transpose^#(@m2)
, 2: transpose^#(@m) -> transpose#1^#(@m, @m)
, 3: transpose#1^#(::(@xs, @xss), @m) ->
c_1(transpose#2^#(split(@m)), split^#(@m))
, 4: split^#(@m) -> split#1^#(@m)
, 5: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls)
, 6: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, 7: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, 8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 1: matrixMultOld^#(@m1, @m2) -> transpose^#(@m2)
, 2: transpose^#(@m) -> transpose#1^#(@m, @m)
, 8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys))
, 7: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l)
, 3: transpose#1^#(::(@xs, @xss), @m) ->
c_1(transpose#2^#(split(@m)), split^#(@m))
, 4: split^#(@m) -> split#1^#(@m)
, 6: split#2^#(::(@x, @xs), @ls) -> split^#(@ls)
, 5: split#1^#(::(@l, @ls)) -> split#2^#(@l, @ls) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m')) }
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:{29}->10:{8}->11:{9}->12:{10,11}: YES(O(1),O(n^1))
---------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :2
2: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :3
3: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :4
4: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :3
5: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_2 makeBase^#(@m) -> makeBase#1^#(@m) :1
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 YES(O(1),O(n^1)).
Strict DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs: { mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :2
2: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :3
3: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :5
4: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_2 makeBase^#(@m) -> makeBase#1^#(@m) :1
5: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :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 YES(O(1),O(n^1)).
Strict DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, mkBase^#(@m) -> mkBase#1^#(@m)
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :4
2: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :5
3: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_2 makeBase^#(@m) -> makeBase#1^#(@m) :1
4: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :2
5: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {1} and add Pre({1}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ mkBase^#(@m) -> mkBase#1^#(@m)
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :5
2: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_2 makeBase^#(@m) -> makeBase#1^#(@m) :3
3: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :4
4: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
5: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { mkBase^#(@m) -> mkBase#1^#(@m) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :4
2: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :3
3: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
4: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
5: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_2 makeBase^#(@m) -> makeBase#1^#(@m) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { mkBase^#(@m) -> mkBase#1^#(@m) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, transpose'^#(@m) -> makeBase^#(@m) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
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: { mkBase^#(@m) -> mkBase#1^#(@m) }
Weak DPs:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, transpose'^#(@m) -> makeBase^#(@m) }
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: mkBase^#(@m) -> mkBase#1^#(@m)
, 2: makeBase^#(@m) -> makeBase#1^#(@m)
, 3: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, 4: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#neg) = {}, Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(::) = {},
Uargs(tuple#2) = {}, Uargs(#abs^#) = {}, Uargs(*^#) = {},
Uargs(#mult^#) = {}, Uargs(+^#) = {}, Uargs(#add^#) = {},
Uargs(attach^#) = {}, Uargs(attach#1^#) = {},
Uargs(attach#2^#) = {}, Uargs(lineMult^#) = {},
Uargs(lineMult#1^#) = {}, Uargs(mult^#) = {}, Uargs(mult#1^#) = {},
Uargs(makeBase^#) = {}, Uargs(makeBase#1^#) = {},
Uargs(mkBase^#) = {}, Uargs(mkBase#1^#) = {},
Uargs(matrixMult^#) = {}, Uargs(matrixMult'^#) = {},
Uargs(transAcc^#) = {}, Uargs(transAcc#1^#) = {},
Uargs(matrixMult'#1^#) = {}, Uargs(matrixMult3^#) = {},
Uargs(matrixMultList^#) = {}, Uargs(matrixMultList#1^#) = {},
Uargs(matrixMultOld^#) = {}, Uargs(transpose^#) = {},
Uargs(transpose#1^#) = {}, Uargs(mult#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {}, Uargs(split#2^#) = {},
Uargs(split#3^#) = {}, Uargs(transpose#2^#) = {},
Uargs(transpose#3^#) = {}, Uargs(transpose'^#) = {},
Uargs(#natmult^#) = {}, Uargs(#pred^#) = {}, Uargs(#succ^#) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[#0] = [0]
[#neg](x1) = [0]
[#pos](x1) = [0]
[#s](x1) = [0]
[::](x1, x2) = [1] x1 + [1] x2 + [3]
[nil] = [0]
[tuple#2](x1, x2) = [0]
[#abs^#](x1) = [0]
[*^#](x1, x2) = [0]
[#mult^#](x1, x2) = [0]
[+^#](x1, x2) = [0]
[#add^#](x1, x2) = [0]
[attach^#](x1, x2) = [0]
[attach#1^#](x1, x2) = [0]
[attach#2^#](x1, x2, x3) = [0]
[lineMult^#](x1, x2) = [0]
[lineMult#1^#](x1, x2) = [0]
[mult^#](x1, x2) = [0]
[mult#1^#](x1, x2) = [0]
[makeBase^#](x1) = [3] x1 + [3]
[makeBase#1^#](x1) = [3] x1 + [2]
[mkBase^#](x1) = [3] x1 + [3]
[mkBase#1^#](x1) = [3] x1 + [0]
[matrixMult^#](x1, x2) = [0]
[matrixMult'^#](x1, x2) = [0]
[transAcc^#](x1, x2) = [0]
[transAcc#1^#](x1, x2) = [0]
[matrixMult'#1^#](x1, x2) = [0]
[matrixMult3^#](x1, x2, x3) = [0]
[matrixMultList^#](x1, x2) = [0]
[matrixMultList#1^#](x1, x2) = [0]
[matrixMultOld^#](x1, x2) = [0]
[transpose^#](x1) = [0]
[transpose#1^#](x1, x2) = [0]
[mult#2^#](x1, x2, x3) = [0]
[split^#](x1) = [0]
[split#1^#](x1) = [0]
[split#2^#](x1, x2) = [0]
[split#3^#](x1, x2, x3) = [0]
[transpose#2^#](x1) = [0]
[transpose#3^#](x1, x2) = [0]
[transpose'^#](x1) = [3] x1 + [3]
[#natmult^#](x1, x2) = [0]
[#pred^#](x1) = [0]
[#succ^#](x1) = [0]
This order satisfies following ordering constraints
[makeBase^#(@m)] = [3] @m + [3]
> [3] @m + [2]
= [makeBase#1^#(@m)]
[makeBase#1^#(::(@l, @m'))] = [3] @l + [3] @m' + [11]
> [3] @l + [3]
= [mkBase^#(@l)]
[mkBase^#(@m)] = [3] @m + [3]
> [3] @m + [0]
= [mkBase#1^#(@m)]
[mkBase#1^#(::(@l, @m'))] = [3] @l + [3] @m' + [9]
> [3] @m' + [3]
= [mkBase^#(@m')]
[transpose'^#(@m)] = [3] @m + [3]
>= [3] @m + [3]
= [makeBase^#(@m)]
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{1,2,3,4}. Here rules are labeled according to the (estimated)
dependency graph
1: mkBase^#(@m) -> mkBase#1^#(@m)
-->_1 mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') :4
2: makeBase^#(@m) -> makeBase#1^#(@m)
-->_1 makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) :3
3: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
4: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
-->_1 mkBase^#(@m) -> mkBase#1^#(@m) :1
5: transpose'^#(@m) -> makeBase^#(@m)
-->_1 makeBase^#(@m) -> makeBase#1^#(@m) :2
- The rules {1,2,3,4} have known complexity. These cover all
predecessors of {5}, 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:
{ makeBase^#(@m) -> makeBase#1^#(@m)
, makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, mkBase^#(@m) -> mkBase#1^#(@m)
, mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, transpose'^#(@m) -> makeBase^#(@m) }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{5} Weak SCC
|
`->2:{1} Weak SCC
|
`->3:{2} Weak SCC
|
`->4:{3,4} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: makeBase^#(@m) -> makeBase#1^#(@m)
, 2: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, 3: mkBase^#(@m) -> mkBase#1^#(@m)
, 4: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m')
, 5: transpose'^#(@m) -> makeBase^#(@m) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 5: transpose'^#(@m) -> makeBase^#(@m)
, 1: makeBase^#(@m) -> makeBase#1^#(@m)
, 2: makeBase#1^#(::(@l, @m')) -> mkBase^#(@l)
, 3: mkBase^#(@m) -> mkBase#1^#(@m)
, 4: mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') }
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 1:{29}->9:{14,15}->15:{1,3,2}: YES(O(1),O(n^1))
----------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :2
2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :3
3: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
4: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :5
5: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :4
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
6: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_1 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :4
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^1)).
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :2
2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :6
3: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :4
4: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
5: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_1 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :3
6: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :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:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :5
2: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :3
3: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
4: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_1 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
5: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :6
6: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :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^1)).
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :4
2: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :6
3: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_1 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
4: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :5
5: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
6: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :3
2: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :5
3: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :4
4: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
5: transAcc#1^#(::(@l, @m'), @base) ->
c_3(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
6: transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
-->_1 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ transpose'^#(@m) ->
c_9(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) }
Weak Trs:
{ #abs(#0()) -> #0()
, #abs(#neg(@x)) -> #pos(@x)
, #abs(#pos(@x)) -> #pos(@x)
, #abs(#s(@x)) -> #pos(#s(@x))
, *(@x, @y) -> #mult(@x, @y)
, #mult(#0(), #0()) -> #0()
, #mult(#0(), #neg(@y)) -> #0()
, #mult(#0(), #pos(@y)) -> #0()
, #mult(#neg(@x), #0()) -> #0()
, #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
, #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #0()) -> #0()
, #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
, #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
, +(@x, @y) -> #add(@x, @y)
, #add(#0(), @y) -> @y
, #add(#neg(#s(#0())), @y) -> #pred(@y)
, #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
, #add(#pos(#s(#0())), @y) -> #succ(@y)
, #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
, attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, lineMult(@l, @m2) -> lineMult#1(@m2, @l)
, lineMult#1(::(@x, @xs), @l) ->
::(mult(@l, @x), lineMult(@l, @xs))
, lineMult#1(nil(), @l) -> nil()
, mult(@l1, @l2) -> mult#1(@l1, @l2)
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, matrixMult(@m1, @m2) ->
matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
, matrixMult'#1(::(@l, @ls), @m2) ->
::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
, matrixMult'#1(nil(), @m2) -> nil()
, matrixMult3(@m1, @m2, @m3) ->
matrixMult(matrixMult(@m1, @m2), @m3)
, matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
, matrixMultList#1(::(@m, @ms), @acc) ->
matrixMultList(matrixMult(@acc, @m), @ms)
, matrixMultList#1(nil(), @acc) -> @acc
, matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
, transpose(@m) -> transpose#1(@m, @m)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
, mult#1(nil(), @l2) -> #abs(#0())
, mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
, mult#2(nil(), @x, @xs) -> #abs(#0())
, split(@m) -> split#1(@m)
, split#1(::(@l, @ls)) -> split#2(@l, @ls)
, split#1(nil()) -> tuple#2(nil(), nil())
, split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
, split#2(nil(), @ls) -> tuple#2(nil(), nil())
, split#3(tuple#2(@ys, @m'), @x, @xs) ->
tuple#2(::(@x, @ys), ::(@xs, @m'))
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base
, transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
, transpose#1(nil(), @m) -> nil()
, transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
, transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
, transpose#3(nil(), @l) -> nil()
, transpose'(@m) -> transAcc(@m, makeBase(@m))
, #pred(#0()) -> #neg(#s(#0()))
, #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
, #pred(#pos(#s(#0()))) -> #0()
, #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
, #succ(#0()) -> #pos(#s(#0()))
, #succ(#neg(#s(#0()))) -> #0()
, #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
, #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
, #natmult(#0(), @y) -> #0()
, #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) }
Weak DPs:
{ attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) }
Weak Trs:
{ attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base }
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:
{ 3: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, 4: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, 5: transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, 6: transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) }
Trs:
{ attach#2(nil(), @x, @xs) -> nil()
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base)) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#neg) = {}, Uargs(#pos) = {}, Uargs(#s) = {},
Uargs(attach) = {}, Uargs(attach#1) = {}, Uargs(::) = {},
Uargs(attach#2) = {}, Uargs(makeBase) = {}, Uargs(makeBase#1) = {},
Uargs(mkBase) = {}, Uargs(transAcc) = {}, Uargs(mkBase#1) = {},
Uargs(tuple#2) = {}, Uargs(transAcc#1) = {}, Uargs(#abs^#) = {},
Uargs(*^#) = {}, Uargs(#mult^#) = {}, Uargs(+^#) = {},
Uargs(#add^#) = {}, Uargs(attach^#) = {}, Uargs(attach#1^#) = {},
Uargs(attach#2^#) = {}, Uargs(lineMult^#) = {},
Uargs(lineMult#1^#) = {}, Uargs(mult^#) = {}, Uargs(mult#1^#) = {},
Uargs(makeBase^#) = {}, Uargs(makeBase#1^#) = {},
Uargs(mkBase^#) = {}, Uargs(mkBase#1^#) = {},
Uargs(matrixMult^#) = {}, Uargs(matrixMult'^#) = {},
Uargs(transAcc^#) = {}, Uargs(transAcc#1^#) = {},
Uargs(matrixMult'#1^#) = {}, Uargs(matrixMult3^#) = {},
Uargs(matrixMultList^#) = {}, Uargs(matrixMultList#1^#) = {},
Uargs(matrixMultOld^#) = {}, Uargs(transpose^#) = {},
Uargs(transpose#1^#) = {}, Uargs(mult#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {}, Uargs(split#2^#) = {},
Uargs(split#3^#) = {}, Uargs(transpose#2^#) = {},
Uargs(transpose#3^#) = {}, Uargs(transpose'^#) = {},
Uargs(#natmult^#) = {}, Uargs(#pred^#) = {}, Uargs(#succ^#) = {},
Uargs(c_1) = {1, 2}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[#0] = [0]
[#neg](x1) = [0]
[#pos](x1) = [0]
[#s](x1) = [0]
[attach](x1, x2) = [1] x1 + [1] x2 + [0]
[attach#1](x1, x2) = [1] x1 + [1] x2 + [0]
[::](x1, x2) = [1] x1 + [1] x2 + [3]
[attach#2](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [3]
[nil] = [0]
[makeBase](x1) = [2] x1 + [3]
[makeBase#1](x1) = [2] x1 + [1]
[mkBase](x1) = [1] x1 + [0]
[transAcc](x1, x2) = [2] x1 + [1] x2 + [0]
[mkBase#1](x1) = [1] x1 + [0]
[tuple#2](x1, x2) = [0]
[transAcc#1](x1, x2) = [2] x1 + [1] x2 + [0]
[#abs^#](x1) = [0]
[*^#](x1, x2) = [0]
[#mult^#](x1, x2) = [0]
[+^#](x1, x2) = [0]
[#add^#](x1, x2) = [0]
[attach^#](x1, x2) = [1] x1 + [1]
[attach#1^#](x1, x2) = [1] x1 + [1]
[attach#2^#](x1, x2, x3) = [1] x3 + [2]
[lineMult^#](x1, x2) = [0]
[lineMult#1^#](x1, x2) = [0]
[mult^#](x1, x2) = [0]
[mult#1^#](x1, x2) = [0]
[makeBase^#](x1) = [0]
[makeBase#1^#](x1) = [0]
[mkBase^#](x1) = [0]
[mkBase#1^#](x1) = [0]
[matrixMult^#](x1, x2) = [0]
[matrixMult'^#](x1, x2) = [0]
[transAcc^#](x1, x2) = [2] x1 + [0]
[transAcc#1^#](x1, x2) = [2] x1 + [0]
[matrixMult'#1^#](x1, x2) = [0]
[matrixMult3^#](x1, x2, x3) = [0]
[matrixMultList^#](x1, x2) = [0]
[matrixMultList#1^#](x1, x2) = [0]
[matrixMultOld^#](x1, x2) = [0]
[transpose^#](x1) = [0]
[transpose#1^#](x1, x2) = [0]
[mult#2^#](x1, x2, x3) = [0]
[split^#](x1) = [0]
[split#1^#](x1) = [0]
[split#2^#](x1, x2) = [0]
[split#3^#](x1, x2, x3) = [0]
[transpose#2^#](x1) = [0]
[transpose#3^#](x1, x2) = [0]
[transpose'^#](x1) = [3] x1 + [3]
[#natmult^#](x1, x2) = [0]
[#pred^#](x1) = [0]
[#succ^#](x1) = [0]
[c_1](x1, x2) = [2] x1 + [1] x2 + [1]
This order satisfies following ordering constraints
[attach(@line, @m)] = [1] @line + [1] @m + [0]
>= [1] @line + [1] @m + [0]
= [attach#1(@line, @m)]
[attach#1(::(@x, @xs), @m)] = [1] @m + [1] @x + [1] @xs + [3]
>= [1] @m + [1] @x + [1] @xs + [3]
= [attach#2(@m, @x, @xs)]
[attach#1(nil(), @m)] = [1] @m + [0]
>= [0]
= [nil()]
[attach#2(::(@l, @ls), @x, @xs)] = [1] @l + [1] @ls + [1] @x + [1] @xs + [6]
>= [1] @l + [1] @ls + [1] @x + [1] @xs + [6]
= [::(::(@x, @l), attach(@xs, @ls))]
[attach#2(nil(), @x, @xs)] = [1] @x + [1] @xs + [3]
> [0]
= [nil()]
[makeBase(@m)] = [2] @m + [3]
> [2] @m + [1]
= [makeBase#1(@m)]
[makeBase#1(::(@l, @m'))] = [2] @l + [2] @m' + [7]
> [1] @l + [0]
= [mkBase(@l)]
[makeBase#1(nil())] = [1]
> [0]
= [nil()]
[mkBase(@m)] = [1] @m + [0]
>= [1] @m + [0]
= [mkBase#1(@m)]
[transAcc(@m, @base)] = [1] @base + [2] @m + [0]
>= [1] @base + [2] @m + [0]
= [transAcc#1(@m, @base)]
[mkBase#1(::(@l, @m'))] = [1] @l + [1] @m' + [3]
>= [1] @m' + [3]
= [::(nil(), mkBase(@m'))]
[mkBase#1(nil())] = [0]
>= [0]
= [nil()]
[transAcc#1(::(@l, @m'), @base)] = [1] @base + [2] @l + [2] @m' + [6]
> [1] @base + [1] @l + [2] @m' + [0]
= [attach(@l, transAcc(@m', @base))]
[transAcc#1(nil(), @base)] = [1] @base + [0]
>= [1] @base + [0]
= [@base]
[attach^#(@line, @m)] = [1] @line + [1]
>= [1] @line + [1]
= [attach#1^#(@line, @m)]
[attach#1^#(::(@x, @xs), @m)] = [1] @x + [1] @xs + [4]
> [1] @xs + [2]
= [attach#2^#(@m, @x, @xs)]
[attach#2^#(::(@l, @ls), @x, @xs)] = [1] @xs + [2]
> [1] @xs + [1]
= [attach^#(@xs, @ls)]
[transAcc^#(@m, @base)] = [2] @m + [0]
>= [2] @m + [0]
= [transAcc#1^#(@m, @base)]
[transAcc#1^#(::(@l, @m'), @base)] = [2] @l + [2] @m' + [6]
> [2] @l + [2] @m' + [3]
= [c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))]
[transpose'^#(@m)] = [3] @m + [3]
> [2] @m + [0]
= [transAcc^#(@m, makeBase(@m))]
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{3,4,5,6}. Here rules are labeled according to the (estimated)
dependency graph
1: attach^#(@line, @m) -> attach#1^#(@line, @m)
-->_1 attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) :3
2: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
-->_1 transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :5
3: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
-->_1 attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) :4
4: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
5: transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
-->_2 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
-->_1 attach^#(@line, @m) -> attach#1^#(@line, @m) :1
6: transpose'^#(@m) -> transAcc^#(@m, makeBase(@m))
-->_1 transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) :2
- The rules {3,4,5,6} 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,5,6} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ attach^#(@line, @m) -> attach#1^#(@line, @m)
, attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) }
Weak Trs:
{ attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{6} Weak SCC
|
`->2:{4,5} Weak SCC
|
`->3:{1,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: attach^#(@line, @m) -> attach#1^#(@line, @m)
, 2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs)
, 3: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, 4: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, 5: transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, 6: transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 6: transpose'^#(@m) -> transAcc^#(@m, makeBase(@m))
, 4: transAcc^#(@m, @base) -> transAcc#1^#(@m, @base)
, 5: transAcc#1^#(::(@l, @m'), @base) ->
c_1(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
, 1: attach^#(@line, @m) -> attach#1^#(@line, @m)
, 3: attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls)
, 2: attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ attach(@line, @m) -> attach#1(@line, @m)
, attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
, attach#1(nil(), @m) -> nil()
, attach#2(::(@l, @ls), @x, @xs) ->
::(::(@x, @l), attach(@xs, @ls))
, attach#2(nil(), @x, @xs) -> nil()
, makeBase(@m) -> makeBase#1(@m)
, makeBase#1(::(@l, @m')) -> mkBase(@l)
, makeBase#1(nil()) -> nil()
, mkBase(@m) -> mkBase#1(@m)
, transAcc(@m, @base) -> transAcc#1(@m, @base)
, mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
, mkBase#1(nil()) -> nil()
, transAcc#1(::(@l, @m'), @base) ->
attach(@l, transAcc(@m', @base))
, transAcc#1(nil(), @base) -> @base }
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
Arrrr..