/export/starexec/sandbox/solver/bin/starexec_run_complexity /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1), ?) proof of /export/starexec/sandbox/benchmark/theBenchmark.xml # AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, INF). (0) CpxTRS (1) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms] (2) TRS for Loop Detection (3) DecreasingLoopProof [LOWER BOUND(ID), 41 ms] (4) BEST (5) proven lower bound (6) LowerBoundPropagationProof [FINISHED, 0 ms] (7) BOUNDS(n^1, INF) (8) TRS for Loop Detection ---------------------------------------- (0) Obligation: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, INF). The TRS R consists of the following rules: breadth(@breadth@1, @breadth@2) -> breadth#1(dequeue(@breadth@1, @breadth@2)) breadth#1(tuple#2(@queue', @elem)) -> breadth#2(@elem, @queue') breadth#2(::(@z, @_@9), @queue') -> breadth#3(breadth#4(@z), @queue') breadth#2(nil, @queue') -> nil breadth#3(tuple#2(@x, @ys), @queue') -> ::(@x, breadth#5(enqueues(@ys, @queue'))) breadth#4(tuple#4(@children@3, @children@4, @children@5, @children@6)) -> children(@children@3, @children@4, @children@5, @children@6) breadth#5(tuple#2(@breadth@7, @breadth@8)) -> breadth(@breadth@7, @breadth@8) children(@a, @b, @l1, @l2) -> tuple#2(tuple#2(@a, @b), children#1(@l1, @b, @l2)) children#1(::(@x, @xs), @b, @l2) -> children#3(@l2, @b, @x, @xs) children#1(nil, @b, @l2) -> children#2(@l2, @b) children#2(::(@y, @ys), @b) -> ::(tuple#4(@y, @b, nil, @ys), nil) children#2(nil, @b) -> nil children#3(::(@y, @ys), @b, @x, @xs) -> ::(tuple#4(@x, @b, nil, @xs), ::(tuple#4(@x, @y, @xs, @ys), nil)) children#3(nil, @b, @x, @xs) -> nil copyover(@copyover@1, @copyover@2) -> copyover#1(tuple#2(@copyover@1, @copyover@2)) copyover#1(tuple#2(@inq, @outq)) -> copyover#2(@inq, @outq) copyover#2(::(@x, @xs), @outq) -> copyover(@xs, ::(@x, @outq)) copyover#2(nil, @outq) -> tuple#2(nil, @outq) dequeue(@dequeue@1, @dequeue@2) -> dequeue#1(tuple#2(@dequeue@1, @dequeue@2)) dequeue#1(tuple#2(@inq, @outq)) -> dequeue#2(@outq, @inq) dequeue#2(::(@y, @ys), @inq) -> tuple#2(tuple#2(@inq, @ys), ::(@y, nil)) dequeue#2(nil, @inq) -> dequeue#3(@inq) dequeue#3(::(@x, @xs)) -> dequeue#4(copyover(::(@x, @xs), nil)) dequeue#3(nil) -> tuple#2(tuple#2(nil, nil), nil) dequeue#4(tuple#2(@dequeue@3, @dequeue@4)) -> dequeue(@dequeue@3, @dequeue@4) empty(@x) -> tuple#2(nil, nil) enqueue(@x, @queue) -> enqueue#1(@queue, @x) enqueue#1(tuple#2(@inq, @outq), @x) -> tuple#2(::(@x, @inq), @outq) enqueues(@l, @queue) -> enqueues#1(@l, @queue) enqueues#1(::(@x, @xs), @queue) -> enqueues(@xs, enqueue(@x, @queue)) enqueues#1(nil, @queue) -> @queue startBreadth(@xs) -> startBreadth#1(@xs) startBreadth#1(::(@x, @xs)) -> startBreadth#2(enqueue(tuple#4(@x, @x, @xs, @xs), empty(#unit))) startBreadth#1(nil) -> nil startBreadth#2(tuple#2(@breadth@1, @breadth@2)) -> breadth(@breadth@1, @breadth@2) S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (1) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID)) Transformed a relative TRS into a decreasing-loop problem. ---------------------------------------- (2) Obligation: Analyzing the following TRS for decreasing loops: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, INF). The TRS R consists of the following rules: breadth(@breadth@1, @breadth@2) -> breadth#1(dequeue(@breadth@1, @breadth@2)) breadth#1(tuple#2(@queue', @elem)) -> breadth#2(@elem, @queue') breadth#2(::(@z, @_@9), @queue') -> breadth#3(breadth#4(@z), @queue') breadth#2(nil, @queue') -> nil breadth#3(tuple#2(@x, @ys), @queue') -> ::(@x, breadth#5(enqueues(@ys, @queue'))) breadth#4(tuple#4(@children@3, @children@4, @children@5, @children@6)) -> children(@children@3, @children@4, @children@5, @children@6) breadth#5(tuple#2(@breadth@7, @breadth@8)) -> breadth(@breadth@7, @breadth@8) children(@a, @b, @l1, @l2) -> tuple#2(tuple#2(@a, @b), children#1(@l1, @b, @l2)) children#1(::(@x, @xs), @b, @l2) -> children#3(@l2, @b, @x, @xs) children#1(nil, @b, @l2) -> children#2(@l2, @b) children#2(::(@y, @ys), @b) -> ::(tuple#4(@y, @b, nil, @ys), nil) children#2(nil, @b) -> nil children#3(::(@y, @ys), @b, @x, @xs) -> ::(tuple#4(@x, @b, nil, @xs), ::(tuple#4(@x, @y, @xs, @ys), nil)) children#3(nil, @b, @x, @xs) -> nil copyover(@copyover@1, @copyover@2) -> copyover#1(tuple#2(@copyover@1, @copyover@2)) copyover#1(tuple#2(@inq, @outq)) -> copyover#2(@inq, @outq) copyover#2(::(@x, @xs), @outq) -> copyover(@xs, ::(@x, @outq)) copyover#2(nil, @outq) -> tuple#2(nil, @outq) dequeue(@dequeue@1, @dequeue@2) -> dequeue#1(tuple#2(@dequeue@1, @dequeue@2)) dequeue#1(tuple#2(@inq, @outq)) -> dequeue#2(@outq, @inq) dequeue#2(::(@y, @ys), @inq) -> tuple#2(tuple#2(@inq, @ys), ::(@y, nil)) dequeue#2(nil, @inq) -> dequeue#3(@inq) dequeue#3(::(@x, @xs)) -> dequeue#4(copyover(::(@x, @xs), nil)) dequeue#3(nil) -> tuple#2(tuple#2(nil, nil), nil) dequeue#4(tuple#2(@dequeue@3, @dequeue@4)) -> dequeue(@dequeue@3, @dequeue@4) empty(@x) -> tuple#2(nil, nil) enqueue(@x, @queue) -> enqueue#1(@queue, @x) enqueue#1(tuple#2(@inq, @outq), @x) -> tuple#2(::(@x, @inq), @outq) enqueues(@l, @queue) -> enqueues#1(@l, @queue) enqueues#1(::(@x, @xs), @queue) -> enqueues(@xs, enqueue(@x, @queue)) enqueues#1(nil, @queue) -> @queue startBreadth(@xs) -> startBreadth#1(@xs) startBreadth#1(::(@x, @xs)) -> startBreadth#2(enqueue(tuple#4(@x, @x, @xs, @xs), empty(#unit))) startBreadth#1(nil) -> nil startBreadth#2(tuple#2(@breadth@1, @breadth@2)) -> breadth(@breadth@1, @breadth@2) S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (3) DecreasingLoopProof (LOWER BOUND(ID)) The following loop(s) give(s) rise to the lower bound Omega(n^1): The rewrite sequence enqueues(::(@x1_0, @xs2_0), @queue) ->^+ enqueues(@xs2_0, enqueue(@x1_0, @queue)) gives rise to a decreasing loop by considering the right hand sides subterm at position []. The pumping substitution is [@xs2_0 / ::(@x1_0, @xs2_0)]. The result substitution is [@queue / enqueue(@x1_0, @queue)]. ---------------------------------------- (4) Complex Obligation (BEST) ---------------------------------------- (5) Obligation: Proved the lower bound n^1 for the following obligation: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, INF). The TRS R consists of the following rules: breadth(@breadth@1, @breadth@2) -> breadth#1(dequeue(@breadth@1, @breadth@2)) breadth#1(tuple#2(@queue', @elem)) -> breadth#2(@elem, @queue') breadth#2(::(@z, @_@9), @queue') -> breadth#3(breadth#4(@z), @queue') breadth#2(nil, @queue') -> nil breadth#3(tuple#2(@x, @ys), @queue') -> ::(@x, breadth#5(enqueues(@ys, @queue'))) breadth#4(tuple#4(@children@3, @children@4, @children@5, @children@6)) -> children(@children@3, @children@4, @children@5, @children@6) breadth#5(tuple#2(@breadth@7, @breadth@8)) -> breadth(@breadth@7, @breadth@8) children(@a, @b, @l1, @l2) -> tuple#2(tuple#2(@a, @b), children#1(@l1, @b, @l2)) children#1(::(@x, @xs), @b, @l2) -> children#3(@l2, @b, @x, @xs) children#1(nil, @b, @l2) -> children#2(@l2, @b) children#2(::(@y, @ys), @b) -> ::(tuple#4(@y, @b, nil, @ys), nil) children#2(nil, @b) -> nil children#3(::(@y, @ys), @b, @x, @xs) -> ::(tuple#4(@x, @b, nil, @xs), ::(tuple#4(@x, @y, @xs, @ys), nil)) children#3(nil, @b, @x, @xs) -> nil copyover(@copyover@1, @copyover@2) -> copyover#1(tuple#2(@copyover@1, @copyover@2)) copyover#1(tuple#2(@inq, @outq)) -> copyover#2(@inq, @outq) copyover#2(::(@x, @xs), @outq) -> copyover(@xs, ::(@x, @outq)) copyover#2(nil, @outq) -> tuple#2(nil, @outq) dequeue(@dequeue@1, @dequeue@2) -> dequeue#1(tuple#2(@dequeue@1, @dequeue@2)) dequeue#1(tuple#2(@inq, @outq)) -> dequeue#2(@outq, @inq) dequeue#2(::(@y, @ys), @inq) -> tuple#2(tuple#2(@inq, @ys), ::(@y, nil)) dequeue#2(nil, @inq) -> dequeue#3(@inq) dequeue#3(::(@x, @xs)) -> dequeue#4(copyover(::(@x, @xs), nil)) dequeue#3(nil) -> tuple#2(tuple#2(nil, nil), nil) dequeue#4(tuple#2(@dequeue@3, @dequeue@4)) -> dequeue(@dequeue@3, @dequeue@4) empty(@x) -> tuple#2(nil, nil) enqueue(@x, @queue) -> enqueue#1(@queue, @x) enqueue#1(tuple#2(@inq, @outq), @x) -> tuple#2(::(@x, @inq), @outq) enqueues(@l, @queue) -> enqueues#1(@l, @queue) enqueues#1(::(@x, @xs), @queue) -> enqueues(@xs, enqueue(@x, @queue)) enqueues#1(nil, @queue) -> @queue startBreadth(@xs) -> startBreadth#1(@xs) startBreadth#1(::(@x, @xs)) -> startBreadth#2(enqueue(tuple#4(@x, @x, @xs, @xs), empty(#unit))) startBreadth#1(nil) -> nil startBreadth#2(tuple#2(@breadth@1, @breadth@2)) -> breadth(@breadth@1, @breadth@2) S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (6) LowerBoundPropagationProof (FINISHED) Propagated lower bound. ---------------------------------------- (7) BOUNDS(n^1, INF) ---------------------------------------- (8) Obligation: Analyzing the following TRS for decreasing loops: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, INF). The TRS R consists of the following rules: breadth(@breadth@1, @breadth@2) -> breadth#1(dequeue(@breadth@1, @breadth@2)) breadth#1(tuple#2(@queue', @elem)) -> breadth#2(@elem, @queue') breadth#2(::(@z, @_@9), @queue') -> breadth#3(breadth#4(@z), @queue') breadth#2(nil, @queue') -> nil breadth#3(tuple#2(@x, @ys), @queue') -> ::(@x, breadth#5(enqueues(@ys, @queue'))) breadth#4(tuple#4(@children@3, @children@4, @children@5, @children@6)) -> children(@children@3, @children@4, @children@5, @children@6) breadth#5(tuple#2(@breadth@7, @breadth@8)) -> breadth(@breadth@7, @breadth@8) children(@a, @b, @l1, @l2) -> tuple#2(tuple#2(@a, @b), children#1(@l1, @b, @l2)) children#1(::(@x, @xs), @b, @l2) -> children#3(@l2, @b, @x, @xs) children#1(nil, @b, @l2) -> children#2(@l2, @b) children#2(::(@y, @ys), @b) -> ::(tuple#4(@y, @b, nil, @ys), nil) children#2(nil, @b) -> nil children#3(::(@y, @ys), @b, @x, @xs) -> ::(tuple#4(@x, @b, nil, @xs), ::(tuple#4(@x, @y, @xs, @ys), nil)) children#3(nil, @b, @x, @xs) -> nil copyover(@copyover@1, @copyover@2) -> copyover#1(tuple#2(@copyover@1, @copyover@2)) copyover#1(tuple#2(@inq, @outq)) -> copyover#2(@inq, @outq) copyover#2(::(@x, @xs), @outq) -> copyover(@xs, ::(@x, @outq)) copyover#2(nil, @outq) -> tuple#2(nil, @outq) dequeue(@dequeue@1, @dequeue@2) -> dequeue#1(tuple#2(@dequeue@1, @dequeue@2)) dequeue#1(tuple#2(@inq, @outq)) -> dequeue#2(@outq, @inq) dequeue#2(::(@y, @ys), @inq) -> tuple#2(tuple#2(@inq, @ys), ::(@y, nil)) dequeue#2(nil, @inq) -> dequeue#3(@inq) dequeue#3(::(@x, @xs)) -> dequeue#4(copyover(::(@x, @xs), nil)) dequeue#3(nil) -> tuple#2(tuple#2(nil, nil), nil) dequeue#4(tuple#2(@dequeue@3, @dequeue@4)) -> dequeue(@dequeue@3, @dequeue@4) empty(@x) -> tuple#2(nil, nil) enqueue(@x, @queue) -> enqueue#1(@queue, @x) enqueue#1(tuple#2(@inq, @outq), @x) -> tuple#2(::(@x, @inq), @outq) enqueues(@l, @queue) -> enqueues#1(@l, @queue) enqueues#1(::(@x, @xs), @queue) -> enqueues(@xs, enqueue(@x, @queue)) enqueues#1(nil, @queue) -> @queue startBreadth(@xs) -> startBreadth#1(@xs) startBreadth#1(::(@x, @xs)) -> startBreadth#2(enqueue(tuple#4(@x, @x, @xs, @xs), empty(#unit))) startBreadth#1(nil) -> nil startBreadth#2(tuple#2(@breadth@1, @breadth@2)) -> breadth(@breadth@1, @breadth@2) S is empty. Rewrite Strategy: INNERMOST