H-Termination proof of ../tpdb/FP/full_haskell/Prelude_mapM

MAYBE H-Termination proof of ../tpdb/FP/full_haskell/Prelude_mapM_1.hs
H-Termination of the given Haskell-Program with start terms could not be shown:

↳ HASKELL

  ↳ LR

mainModule Main

((mapM :: Monad a => (b -> a c) -> [b] -> a [c]) :: Monad a => (b -> a c) -> [b] -> a [c])

module Main where

import qualified Prelude

Lambda Reductions:
The following Lambda expression

\xs→return (x : xs)

is transformed to

sequence0 x xs = return (x : xs)

The following Lambda expression

\x→sequence cs >>= sequence0 x

is transformed to

sequence1 cs x = sequence cs >>= sequence0 x

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

mainModule Main

((mapM :: Monad a => (c -> a b) -> [c] -> a [b]) :: Monad a => (c -> a b) -> [c] -> a [b])

module Main where

import qualified Prelude

Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

mainModule Main

((mapM :: Monad b => (a -> b c) -> [a] -> b [c]) :: Monad b => (a -> b c) -> [a] -> b [c])

module Main where

import qualified Prelude

Num Reduction:All numbers are transformed to thier corresponding representation with Succ, Pred and Zero.

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

mainModule Main

(mapM :: Monad c => (a -> c b) -> [a] -> c [b])

module Main where

import qualified Prelude

Haskell To QDPs

digraph dp_graph {
node [outthreshold=100, inthreshold=100];1[label="mapM\n",fontsize=16,color="grey",shape="box"];1 -> 3[label="",style="dashed", color="grey", weight=3];
3[label="mapM vx3\n",fontsize=16,color="grey",shape="box"];3 -> 4[label="",style="dashed", color="grey", weight=3];
4[label="mapM vx3 vx4\n",fontsize=16,color="black",shape="triangle"];4 -> 5[label="",style="solid", color="black", weight=3];
5[label="sequence . map vx3\n",fontsize=16,color="black",shape="box"];5 -> 6[label="",style="solid", color="black", weight=3];
6[label="sequence (map vx3 vx4)\n",fontsize=16,color="burlywood",shape="triangle"];107[label="vx4/vx40 : vx41",fontsize=10,color="white",style="solid",shape="box"];6 -> 107[label="",style="solid", color="burlywood", weight=9];
107 -> 7[label="",style="solid", color="burlywood", weight=3];
108[label="vx4/[]",fontsize=10,color="white",style="solid",shape="box"];6 -> 108[label="",style="solid", color="burlywood", weight=9];
108 -> 8[label="",style="solid", color="burlywood", weight=3];
7[label="sequence (map vx3 (vx40 : vx41))\n",fontsize=16,color="black",shape="box"];7 -> 9[label="",style="solid", color="black", weight=3];
8[label="sequence (map vx3 [])\n",fontsize=16,color="black",shape="box"];8 -> 10[label="",style="solid", color="black", weight=3];
9[label="sequence (vx3 vx40 : map vx3 vx41)\n",fontsize=16,color="black",shape="box"];9 -> 11[label="",style="solid", color="black", weight=3];
10[label="sequence []\n",fontsize=16,color="black",shape="box"];10 -> 12[label="",style="solid", color="black", weight=3];
11[label="vx3 vx40 >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="blue",shape="box"];109[label=">>= :: (IO a) -> (a -> IO ([] a)) -> IO ([] a)",fontsize=10,color="white",style="solid",shape="box"];11 -> 109[label="",style="solid", color="blue", weight=9];
109 -> 13[label="",style="solid", color="blue", weight=3];
110[label=">>= :: (Maybe a) -> (a -> Maybe ([] a)) -> Maybe ([] a)",fontsize=10,color="white",style="solid",shape="box"];11 -> 110[label="",style="solid", color="blue", weight=9];
110 -> 14[label="",style="solid", color="blue", weight=3];
111[label=">>= :: ([] a) -> (a -> [] ([] a)) -> [] ([] a)",fontsize=10,color="white",style="solid",shape="box"];11 -> 111[label="",style="solid", color="blue", weight=9];
111 -> 15[label="",style="solid", color="blue", weight=3];
12[label="return []\n",fontsize=16,color="blue",shape="box"];112[label="return :: ([] a) -> IO ([] a)",fontsize=10,color="white",style="solid",shape="box"];12 -> 112[label="",style="solid", color="blue", weight=9];
112 -> 16[label="",style="solid", color="blue", weight=3];
113[label="return :: ([] a) -> Maybe ([] a)",fontsize=10,color="white",style="solid",shape="box"];12 -> 113[label="",style="solid", color="blue", weight=9];
113 -> 17[label="",style="solid", color="blue", weight=3];
114[label="return :: ([] a) -> [] ([] a)",fontsize=10,color="white",style="solid",shape="box"];12 -> 114[label="",style="solid", color="blue", weight=9];
114 -> 18[label="",style="solid", color="blue", weight=3];
13[label="vx3 vx40 >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="black",shape="box"];13 -> 19[label="",style="solid", color="black", weight=3];
14 -> 20[label="",style="dashed", color="red", weight=0];
14[label="vx3 vx40 >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="magenta"];14 -> 21[label="",style="dashed", color="magenta", weight=3];
15 -> 22[label="",style="dashed", color="red", weight=0];
15[label="vx3 vx40 >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="magenta"];15 -> 23[label="",style="dashed", color="magenta", weight=3];
16[label="return []\n",fontsize=16,color="black",shape="box"];16 -> 24[label="",style="solid", color="black", weight=3];
17[label="return []\n",fontsize=16,color="black",shape="box"];17 -> 25[label="",style="solid", color="black", weight=3];
18[label="return []\n",fontsize=16,color="black",shape="box"];18 -> 26[label="",style="solid", color="black", weight=3];
19[label="primbindIO (vx3 vx40) (sequence1 (map vx3 vx41))\n",fontsize=16,color="black",shape="box"];19 -> 27[label="",style="solid", color="black", weight=3];
21[label="vx3 vx40\n",fontsize=16,color="green",shape="box"];21 -> 28[label="",style="dashed", color="green", weight=3];
20[label="vx5 >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="burlywood",shape="triangle"];117[label="vx5/Nothing",fontsize=10,color="white",style="solid",shape="box"];20 -> 117[label="",style="solid", color="burlywood", weight=9];
117 -> 29[label="",style="solid", color="burlywood", weight=3];
118[label="vx5/Just vx50",fontsize=10,color="white",style="solid",shape="box"];20 -> 118[label="",style="solid", color="burlywood", weight=9];
118 -> 30[label="",style="solid", color="burlywood", weight=3];
23[label="vx3 vx40\n",fontsize=16,color="green",shape="box"];23 -> 34[label="",style="dashed", color="green", weight=3];
22[label="vx6 >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="burlywood",shape="triangle"];119[label="vx6/vx60 : vx61",fontsize=10,color="white",style="solid",shape="box"];22 -> 119[label="",style="solid", color="burlywood", weight=9];
119 -> 32[label="",style="solid", color="burlywood", weight=3];
120[label="vx6/[]",fontsize=10,color="white",style="solid",shape="box"];22 -> 120[label="",style="solid", color="burlywood", weight=9];
120 -> 33[label="",style="solid", color="burlywood", weight=3];
24[label="primretIO []\n",fontsize=16,color="black",shape="box"];24 -> 35[label="",style="solid", color="black", weight=3];
25[label="Just []\n",fontsize=16,color="green",shape="box"];26[label="[] : []\n",fontsize=16,color="green",shape="box"];27[label="terminator (vx3 vx40) (sequence1 (map vx3 vx41))\n",fontsize=16,color="black",shape="box"];27 -> 36[label="",style="solid", color="black", weight=3];
28[label="vx40\n",fontsize=16,color="green",shape="box"];29[label="Nothing >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="black",shape="box"];29 -> 37[label="",style="solid", color="black", weight=3];
30[label="Just vx50 >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="black",shape="box"];30 -> 38[label="",style="solid", color="black", weight=3];
34[label="vx40\n",fontsize=16,color="green",shape="box"];32[label="vx60 : vx61 >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="black",shape="box"];32 -> 39[label="",style="solid", color="black", weight=3];
33[label="[] >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="black",shape="box"];33 -> 40[label="",style="solid", color="black", weight=3];
35[label="terminator []\n",fontsize=16,color="black",shape="box"];35 -> 41[label="",style="solid", color="black", weight=3];
36[label="ter0m (vx3 vx40) (sequence1 (map vx3 vx41))\n",fontsize=16,color="green",shape="box"];36 -> 42[label="",style="dashed", color="green", weight=3];
36 -> 43[label="",style="dashed", color="green", weight=3];
37[label="Nothing\n",fontsize=16,color="green",shape="box"];38[label="sequence1 (map vx3 vx41) vx50\n",fontsize=16,color="black",shape="box"];38 -> 44[label="",style="solid", color="black", weight=3];
39 -> 45[label="",style="dashed", color="red", weight=0];
39[label="sequence1 (map vx3 vx41) vx60 ++ (vx61 >>= sequence1 (map vx3 vx41))\n",fontsize=16,color="magenta"];39 -> 46[label="",style="dashed", color="magenta", weight=3];
40[label="[]\n",fontsize=16,color="green",shape="box"];41[label="ter1m []\n",fontsize=16,color="green",shape="box"];41 -> 47[label="",style="dashed", color="green", weight=3];
42[label="vx3 vx40\n",fontsize=16,color="green",shape="box"];42 -> 48[label="",style="dashed", color="green", weight=3];
43[label="sequence1 (map vx3 vx41)\n",fontsize=16,color="grey",shape="box"];43 -> 49[label="",style="dashed", color="grey", weight=3];
44 -> 50[label="",style="dashed", color="red", weight=0];
44[label="sequence (map vx3 vx41) >>= sequence0 vx50\n",fontsize=16,color="magenta"];44 -> 51[label="",style="dashed", color="magenta", weight=3];
46 -> 22[label="",style="dashed", color="red", weight=0];
46[label="vx61 >>= sequence1 (map vx3 vx41)\n",fontsize=16,color="magenta"];46 -> 52[label="",style="dashed", color="magenta", weight=3];
45[label="sequence1 (map vx3 vx41) vx60 ++ vx7\n",fontsize=16,color="black",shape="triangle"];45 -> 53[label="",style="solid", color="black", weight=3];
47[label="[]\n",fontsize=16,color="green",shape="box"];48[label="vx40\n",fontsize=16,color="green",shape="box"];49[label="sequence1 (map vx3 vx41) vx8\n",fontsize=16,color="black",shape="triangle"];49 -> 54[label="",style="solid", color="black", weight=3];
51 -> 6[label="",style="dashed", color="red", weight=0];
51[label="sequence (map vx3 vx41)\n",fontsize=16,color="magenta"];51 -> 55[label="",style="dashed", color="magenta", weight=3];
50[label="vx9 >>= sequence0 vx50\n",fontsize=16,color="burlywood",shape="triangle"];125[label="vx9/Nothing",fontsize=10,color="white",style="solid",shape="box"];50 -> 125[label="",style="solid", color="burlywood", weight=9];
125 -> 56[label="",style="solid", color="burlywood", weight=3];
126[label="vx9/Just vx90",fontsize=10,color="white",style="solid",shape="box"];50 -> 126[label="",style="solid", color="burlywood", weight=9];
126 -> 57[label="",style="solid", color="burlywood", weight=3];
52[label="vx61\n",fontsize=16,color="green",shape="box"];53 -> 58[label="",style="dashed", color="red", weight=0];
53[label="(sequence (map vx3 vx41) >>= sequence0 vx60) ++ vx7\n",fontsize=16,color="magenta"];53 -> 59[label="",style="dashed", color="magenta", weight=3];
54 -> 60[label="",style="dashed", color="red", weight=0];
54[label="sequence (map vx3 vx41) >>= sequence0 vx8\n",fontsize=16,color="magenta"];54 -> 61[label="",style="dashed", color="magenta", weight=3];
55[label="vx41\n",fontsize=16,color="green",shape="box"];56[label="Nothing >>= sequence0 vx50\n",fontsize=16,color="black",shape="box"];56 -> 62[label="",style="solid", color="black", weight=3];
57[label="Just vx90 >>= sequence0 vx50\n",fontsize=16,color="black",shape="box"];57 -> 63[label="",style="solid", color="black", weight=3];
59 -> 6[label="",style="dashed", color="red", weight=0];
59[label="sequence (map vx3 vx41)\n",fontsize=16,color="magenta"];59 -> 64[label="",style="dashed", color="magenta", weight=3];
58[label="(vx10 >>= sequence0 vx60) ++ vx7\n",fontsize=16,color="burlywood",shape="triangle"];130[label="vx10/vx100 : vx101",fontsize=10,color="white",style="solid",shape="box"];58 -> 130[label="",style="solid", color="burlywood", weight=9];
130 -> 65[label="",style="solid", color="burlywood", weight=3];
131[label="vx10/[]",fontsize=10,color="white",style="solid",shape="box"];58 -> 131[label="",style="solid", color="burlywood", weight=9];
131 -> 66[label="",style="solid", color="burlywood", weight=3];
61 -> 6[label="",style="dashed", color="red", weight=0];
61[label="sequence (map vx3 vx41)\n",fontsize=16,color="magenta"];61 -> 67[label="",style="dashed", color="magenta", weight=3];
60[label="vx11 >>= sequence0 vx8\n",fontsize=16,color="black",shape="triangle"];60 -> 68[label="",style="solid", color="black", weight=3];
62[label="Nothing\n",fontsize=16,color="green",shape="box"];63[label="sequence0 vx50 vx90\n",fontsize=16,color="black",shape="box"];63 -> 69[label="",style="solid", color="black", weight=3];
64[label="vx41\n",fontsize=16,color="green",shape="box"];65[label="(vx100 : vx101 >>= sequence0 vx60) ++ vx7\n",fontsize=16,color="black",shape="box"];65 -> 70[label="",style="solid", color="black", weight=3];
66[label="([] >>= sequence0 vx60) ++ vx7\n",fontsize=16,color="black",shape="box"];66 -> 71[label="",style="solid", color="black", weight=3];
67[label="vx41\n",fontsize=16,color="green",shape="box"];68[label="primbindIO vx11 (sequence0 vx8)\n",fontsize=16,color="black",shape="box"];68 -> 72[label="",style="solid", color="black", weight=3];
69[label="return (vx50 : vx90)\n",fontsize=16,color="black",shape="box"];69 -> 73[label="",style="solid", color="black", weight=3];
70[label="(sequence0 vx60 vx100 ++ (vx101 >>= sequence0 vx60)) ++ vx7\n",fontsize=16,color="black",shape="box"];70 -> 74[label="",style="solid", color="black", weight=3];
71[label="[] ++ vx7\n",fontsize=16,color="black",shape="triangle"];71 -> 75[label="",style="solid", color="black", weight=3];
72[label="terminator vx11 (sequence0 vx8)\n",fontsize=16,color="black",shape="box"];72 -> 76[label="",style="solid", color="black", weight=3];
73[label="Just (vx50 : vx90)\n",fontsize=16,color="green",shape="box"];74[label="(return (vx60 : vx100) ++ (vx101 >>= sequence0 vx60)) ++ vx7\n",fontsize=16,color="black",shape="box"];74 -> 77[label="",style="solid", color="black", weight=3];
75[label="vx7\n",fontsize=16,color="green",shape="box"];76[label="ter2m vx11 (sequence0 vx8)\n",fontsize=16,color="green",shape="box"];76 -> 78[label="",style="dashed", color="green", weight=3];
76 -> 79[label="",style="dashed", color="green", weight=3];
77[label="(((vx60 : vx100) : []) ++ (vx101 >>= sequence0 vx60)) ++ vx7\n",fontsize=16,color="black",shape="box"];77 -> 80[label="",style="solid", color="black", weight=3];
78[label="vx11\n",fontsize=16,color="green",shape="box"];79[label="sequence0 vx8\n",fontsize=16,color="grey",shape="box"];79 -> 81[label="",style="dashed", color="grey", weight=3];
80 -> 82[label="",style="dashed", color="red", weight=0];
80[label="((vx60 : vx100) : [] ++ (vx101 >>= sequence0 vx60)) ++ vx7\n",fontsize=16,color="magenta"];80 -> 83[label="",style="dashed", color="magenta", weight=3];
81[label="sequence0 vx8 vx12\n",fontsize=16,color="black",shape="triangle"];81 -> 84[label="",style="solid", color="black", weight=3];
83 -> 71[label="",style="dashed", color="red", weight=0];
83[label="[] ++ (vx101 >>= sequence0 vx60)\n",fontsize=16,color="magenta"];83 -> 85[label="",style="dashed", color="magenta", weight=3];
82[label="((vx60 : vx100) : vx13) ++ vx7\n",fontsize=16,color="black",shape="triangle"];82 -> 86[label="",style="solid", color="black", weight=3];
84[label="return (vx8 : vx12)\n",fontsize=16,color="black",shape="box"];84 -> 87[label="",style="solid", color="black", weight=3];
85[label="vx101 >>= sequence0 vx60\n",fontsize=16,color="burlywood",shape="triangle"];135[label="vx101/vx1010 : vx1011",fontsize=10,color="white",style="solid",shape="box"];85 -> 135[label="",style="solid", color="burlywood", weight=9];
135 -> 88[label="",style="solid", color="burlywood", weight=3];
136[label="vx101/[]",fontsize=10,color="white",style="solid",shape="box"];85 -> 136[label="",style="solid", color="burlywood", weight=9];
136 -> 89[label="",style="solid", color="burlywood", weight=3];
86[label="(vx60 : vx100) : vx13 ++ vx7\n",fontsize=16,color="green",shape="box"];86 -> 90[label="",style="dashed", color="green", weight=3];
87[label="primretIO (vx8 : vx12)\n",fontsize=16,color="black",shape="box"];87 -> 91[label="",style="solid", color="black", weight=3];
88[label="vx1010 : vx1011 >>= sequence0 vx60\n",fontsize=16,color="black",shape="box"];88 -> 92[label="",style="solid", color="black", weight=3];
89[label="[] >>= sequence0 vx60\n",fontsize=16,color="black",shape="box"];89 -> 93[label="",style="solid", color="black", weight=3];
90[label="vx13 ++ vx7\n",fontsize=16,color="burlywood",shape="triangle"];137[label="vx13/vx130 : vx131",fontsize=10,color="white",style="solid",shape="box"];90 -> 137[label="",style="solid", color="burlywood", weight=9];
137 -> 94[label="",style="solid", color="burlywood", weight=3];
138[label="vx13/[]",fontsize=10,color="white",style="solid",shape="box"];90 -> 138[label="",style="solid", color="burlywood", weight=9];
138 -> 95[label="",style="solid", color="burlywood", weight=3];
91[label="terminator (vx8 : vx12)\n",fontsize=16,color="black",shape="box"];91 -> 96[label="",style="solid", color="black", weight=3];
92 -> 90[label="",style="dashed", color="red", weight=0];
92[label="sequence0 vx60 vx1010 ++ (vx1011 >>= sequence0 vx60)\n",fontsize=16,color="magenta"];92 -> 97[label="",style="dashed", color="magenta", weight=3];
92 -> 98[label="",style="dashed", color="magenta", weight=3];
93[label="[]\n",fontsize=16,color="green",shape="box"];94[label="(vx130 : vx131) ++ vx7\n",fontsize=16,color="black",shape="box"];94 -> 99[label="",style="solid", color="black", weight=3];
95[label="[] ++ vx7\n",fontsize=16,color="black",shape="box"];95 -> 100[label="",style="solid", color="black", weight=3];
96[label="ter3m (vx8 : vx12)\n",fontsize=16,color="green",shape="box"];96 -> 101[label="",style="dashed", color="green", weight=3];
97 -> 85[label="",style="dashed", color="red", weight=0];
97[label="vx1011 >>= sequence0 vx60\n",fontsize=16,color="magenta"];97 -> 102[label="",style="dashed", color="magenta", weight=3];
98[label="sequence0 vx60 vx1010\n",fontsize=16,color="black",shape="box"];98 -> 103[label="",style="solid", color="black", weight=3];
99[label="vx130 : vx131 ++ vx7\n",fontsize=16,color="green",shape="box"];99 -> 104[label="",style="dashed", color="green", weight=3];
100[label="vx7\n",fontsize=16,color="green",shape="box"];101[label="vx8 : vx12\n",fontsize=16,color="green",shape="box"];102[label="vx1011\n",fontsize=16,color="green",shape="box"];103[label="return (vx60 : vx1010)\n",fontsize=16,color="black",shape="box"];103 -> 105[label="",style="solid", color="black", weight=3];
104 -> 90[label="",style="dashed", color="red", weight=0];
104[label="vx131 ++ vx7\n",fontsize=16,color="magenta"];104 -> 106[label="",style="dashed", color="magenta", weight=3];
105[label="(vx60 : vx1010) : []\n",fontsize=16,color="green",shape="box"];106[label="vx131\n",fontsize=16,color="green",shape="box"];}

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_sequence1(vx3, vx41, vx8, h, ba) → new_sequence(vx3, vx41, ty_IO, h, ba)
new_gtGtEs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_Maybe, h, ba)
new_gtGtEs1(vx3, vx41, h, ba) → new_psPs0(vx3, vx41, h, ba)
new_sequence(vx3, :(vx40, vx41), ty_IO, h, ba) → new_sequence(vx3, vx41, ty_IO, h, ba)
new_psPs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_[], h, ba)
new_sequence(vx3, :(vx40, vx41), ty_Maybe, h, ba) → new_gtGtEs0(vx3, vx41, h, ba)
new_sequence(vx3, :(vx40, vx41), ty_[], h, ba) → new_gtGtEs1(vx3, vx41, h, ba)
new_gtGtEs1(vx3, vx41, h, ba) → new_gtGtEs1(vx3, vx41, h, ba)

The TRS R consists of the following rules:

new_gtGtEs3([], vx60, h) → []
new_psPs2(vx7, h) → vx7
new_psPs1([], vx7, h) → vx7
new_psPs5(vx3, vx41, vx60, vx7, h, ba) → new_psPs3(new_sequence0(vx3, vx41, ty_[], h, ba), vx60, vx7, h)
new_gtGtEs2(:(vx60, vx61), vx3, vx41, h, ba) → new_psPs5(vx3, vx41, vx60, new_gtGtEs2(vx61, vx3, vx41, h, ba), h, ba)
new_psPs4(vx60, vx100, vx13, vx7, h) → :(:(vx60, vx100), new_psPs1(vx13, vx7, h))
new_psPs1(:(vx130, vx131), vx7, h) → :(vx130, new_psPs1(vx131, vx7, h))
new_gtGtEs2([], vx3, vx41, h, ba) → []
new_psPs3(:(vx100, vx101), vx60, vx7, h) → new_psPs4(vx60, vx100, new_psPs2(new_gtGtEs3(vx101, vx60, h), h), vx7, h)
new_psPs3([], vx60, vx7, h) → new_psPs2(vx7, h)
new_gtGtEs3(:(vx1010, vx1011), vx60, h) → new_psPs1(:(:(vx60, vx1010), []), new_gtGtEs3(vx1011, vx60, h), h)

The set Q consists of the following terms:

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 3 SCCs with 1 less node.

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                          ↳ UsableRulesProof

                        ↳ QDP

                        ↳ QDP

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_sequence(vx3, :(vx40, vx41), ty_IO, h, ba) → new_sequence(vx3, vx41, ty_IO, h, ba)

The TRS R consists of the following rules:

new_gtGtEs3([], vx60, h) → []
new_psPs2(vx7, h) → vx7
new_psPs1([], vx7, h) → vx7
new_psPs5(vx3, vx41, vx60, vx7, h, ba) → new_psPs3(new_sequence0(vx3, vx41, ty_[], h, ba), vx60, vx7, h)
new_gtGtEs2(:(vx60, vx61), vx3, vx41, h, ba) → new_psPs5(vx3, vx41, vx60, new_gtGtEs2(vx61, vx3, vx41, h, ba), h, ba)
new_psPs4(vx60, vx100, vx13, vx7, h) → :(:(vx60, vx100), new_psPs1(vx13, vx7, h))
new_psPs1(:(vx130, vx131), vx7, h) → :(vx130, new_psPs1(vx131, vx7, h))
new_gtGtEs2([], vx3, vx41, h, ba) → []
new_psPs3(:(vx100, vx101), vx60, vx7, h) → new_psPs4(vx60, vx100, new_psPs2(new_gtGtEs3(vx101, vx60, h), h), vx7, h)
new_psPs3([], vx60, vx7, h) → new_psPs2(vx7, h)
new_gtGtEs3(:(vx1010, vx1011), vx60, h) → new_psPs1(:(:(vx60, vx1010), []), new_gtGtEs3(vx1011, vx60, h), h)

The set Q consists of the following terms:

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                          ↳ UsableRulesProof

                            ↳ QDP

                              ↳ QReductionProof

                        ↳ QDP

                        ↳ QDP

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_sequence(vx3, :(vx40, vx41), ty_IO, h, ba) → new_sequence(vx3, vx41, ty_IO, h, ba)

R is empty.
The set Q consists of the following terms:

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                          ↳ UsableRulesProof

                            ↳ QDP

                              ↳ QReductionProof

                                ↳ QDP

                                  ↳ QDPSizeChangeProof

                        ↳ QDP

                        ↳ QDP

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_sequence(vx3, :(vx40, vx41), ty_IO, h, ba) → new_sequence(vx3, vx41, ty_IO, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

new_sequence(vx3, :(vx40, vx41), ty_IO, h, ba) → new_sequence(vx3, vx41, ty_IO, h, ba)
The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3, 4 >= 4, 5 >= 5

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                        ↳ QDP

                          ↳ UsableRulesProof

                        ↳ QDP

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_Maybe, h, ba)
new_sequence(vx3, :(vx40, vx41), ty_Maybe, h, ba) → new_gtGtEs0(vx3, vx41, h, ba)

The TRS R consists of the following rules:

new_gtGtEs3([], vx60, h) → []
new_psPs2(vx7, h) → vx7
new_psPs1([], vx7, h) → vx7
new_psPs5(vx3, vx41, vx60, vx7, h, ba) → new_psPs3(new_sequence0(vx3, vx41, ty_[], h, ba), vx60, vx7, h)
new_gtGtEs2(:(vx60, vx61), vx3, vx41, h, ba) → new_psPs5(vx3, vx41, vx60, new_gtGtEs2(vx61, vx3, vx41, h, ba), h, ba)
new_psPs4(vx60, vx100, vx13, vx7, h) → :(:(vx60, vx100), new_psPs1(vx13, vx7, h))
new_psPs1(:(vx130, vx131), vx7, h) → :(vx130, new_psPs1(vx131, vx7, h))
new_gtGtEs2([], vx3, vx41, h, ba) → []
new_psPs3(:(vx100, vx101), vx60, vx7, h) → new_psPs4(vx60, vx100, new_psPs2(new_gtGtEs3(vx101, vx60, h), h), vx7, h)
new_psPs3([], vx60, vx7, h) → new_psPs2(vx7, h)
new_gtGtEs3(:(vx1010, vx1011), vx60, h) → new_psPs1(:(:(vx60, vx1010), []), new_gtGtEs3(vx1011, vx60, h), h)

The set Q consists of the following terms:

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                        ↳ QDP

                          ↳ UsableRulesProof

                            ↳ QDP

                              ↳ QReductionProof

                        ↳ QDP

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_Maybe, h, ba)
new_sequence(vx3, :(vx40, vx41), ty_Maybe, h, ba) → new_gtGtEs0(vx3, vx41, h, ba)

R is empty.
The set Q consists of the following terms:

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                        ↳ QDP

                          ↳ UsableRulesProof

                            ↳ QDP

                              ↳ QReductionProof

                                ↳ QDP

                                  ↳ QDPSizeChangeProof

                        ↳ QDP

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_Maybe, h, ba)
new_sequence(vx3, :(vx40, vx41), ty_Maybe, h, ba) → new_gtGtEs0(vx3, vx41, h, ba)

From the DPs we obtained the following set of size-change graphs:

new_sequence(vx3, :(vx40, vx41), ty_Maybe, h, ba) → new_gtGtEs0(vx3, vx41, h, ba)
The graph contains the following edges 1 >= 1, 2 > 2, 4 >= 3, 5 >= 4
new_gtGtEs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_Maybe, h, ba)
The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 4, 4 >= 5

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                        ↳ QDP

                        ↳ QDP

                          ↳ UsableRulesProof

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs1(vx3, vx41, h, ba) → new_psPs0(vx3, vx41, h, ba)
new_psPs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_[], h, ba)
new_gtGtEs1(vx3, vx41, h, ba) → new_gtGtEs1(vx3, vx41, h, ba)
new_sequence(vx3, :(vx40, vx41), ty_[], h, ba) → new_gtGtEs1(vx3, vx41, h, ba)

The TRS R consists of the following rules:

new_gtGtEs3([], vx60, h) → []
new_psPs2(vx7, h) → vx7
new_psPs1([], vx7, h) → vx7
new_psPs5(vx3, vx41, vx60, vx7, h, ba) → new_psPs3(new_sequence0(vx3, vx41, ty_[], h, ba), vx60, vx7, h)
new_gtGtEs2(:(vx60, vx61), vx3, vx41, h, ba) → new_psPs5(vx3, vx41, vx60, new_gtGtEs2(vx61, vx3, vx41, h, ba), h, ba)
new_psPs4(vx60, vx100, vx13, vx7, h) → :(:(vx60, vx100), new_psPs1(vx13, vx7, h))
new_psPs1(:(vx130, vx131), vx7, h) → :(vx130, new_psPs1(vx131, vx7, h))
new_gtGtEs2([], vx3, vx41, h, ba) → []
new_psPs3(:(vx100, vx101), vx60, vx7, h) → new_psPs4(vx60, vx100, new_psPs2(new_gtGtEs3(vx101, vx60, h), h), vx7, h)
new_psPs3([], vx60, vx7, h) → new_psPs2(vx7, h)
new_gtGtEs3(:(vx1010, vx1011), vx60, h) → new_psPs1(:(:(vx60, vx1010), []), new_gtGtEs3(vx1011, vx60, h), h)

The set Q consists of the following terms:

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                        ↳ QDP

                        ↳ QDP

                          ↳ UsableRulesProof

                            ↳ QDP

                              ↳ QReductionProof

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs1(vx3, vx41, h, ba) → new_psPs0(vx3, vx41, h, ba)
new_psPs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_[], h, ba)
new_gtGtEs1(vx3, vx41, h, ba) → new_gtGtEs1(vx3, vx41, h, ba)
new_sequence(vx3, :(vx40, vx41), ty_[], h, ba) → new_gtGtEs1(vx3, vx41, h, ba)

R is empty.
The set Q consists of the following terms:

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_psPs3(:(x0, x1), x2, x3, x4)
new_psPs4(x0, x1, x2, x3, x4)
new_psPs1(:(x0, x1), x2, x3)
new_psPs3([], x0, x1, x2)
new_psPs2(x0, x1)
new_psPs1([], x0, x1)
new_gtGtEs3(:(x0, x1), x2, x3)
new_gtGtEs2([], x0, x1, x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_gtGtEs3([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3, x4, x5)

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                        ↳ QDP

                        ↳ QDP

                          ↳ UsableRulesProof

                            ↳ QDP

                              ↳ QReductionProof

                                ↳ QDP

                                  ↳ UsableRulesReductionPairsProof

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs1(vx3, vx41, h, ba) → new_psPs0(vx3, vx41, h, ba)
new_psPs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_[], h, ba)
new_sequence(vx3, :(vx40, vx41), ty_[], h, ba) → new_gtGtEs1(vx3, vx41, h, ba)
new_gtGtEs1(vx3, vx41, h, ba) → new_gtGtEs1(vx3, vx41, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

The following dependency pairs can be deleted:

new_sequence(vx3, :(vx40, vx41), ty_[], h, ba) → new_gtGtEs1(vx3, vx41, h, ba)

No rules are removed from R.

Used ordering: POLO with Polynomial interpretation [25]:

POL(:(x₁, x₂)) = x₁ + 2·x₂
POL(new_gtGtEs1(x₁, x₂, x₃, x₄)) = x₁ + x₂ + x₃ + x₄
POL(new_psPs0(x₁, x₂, x₃, x₄)) = x₁ + x₂ + x₃ + x₄
POL(new_sequence(x₁, x₂, x₃, x₄, x₅)) = x₁ + x₂ + 2·x₃ + x₄ + x₅
POL(ty_[]) = 0

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                        ↳ QDP

                        ↳ QDP

                          ↳ UsableRulesProof

                            ↳ QDP

                              ↳ QReductionProof

                                ↳ QDP

                                  ↳ UsableRulesReductionPairsProof

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs1(vx3, vx41, h, ba) → new_psPs0(vx3, vx41, h, ba)
new_psPs0(vx3, vx41, h, ba) → new_sequence(vx3, vx41, ty_[], h, ba)
new_gtGtEs1(vx3, vx41, h, ba) → new_gtGtEs1(vx3, vx41, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ DependencyGraphProof

                      ↳ AND

                        ↳ QDP

                        ↳ QDP

                        ↳ QDP

                          ↳ UsableRulesProof

                            ↳ QDP

                              ↳ QReductionProof

                                ↳ QDP

                                  ↳ UsableRulesReductionPairsProof

                                    ↳ QDP

                                      ↳ DependencyGraphProof

                                        ↳ QDP

                                          ↳ NonTerminationProof

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs1(vx3, vx41, h, ba) → new_gtGtEs1(vx3, vx41, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

new_gtGtEs1(vx3, vx41, h, ba) → new_gtGtEs1(vx3, vx41, h, ba)

The TRS R consists of the following rules:none

s = new_gtGtEs1(vx3, vx41, h, ba) evaluates to t =new_gtGtEs1(vx3, vx41, h, ba)

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:

Semiunifier: [ ]
Matcher: [ ]

Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from new_gtGtEs1(vx3, vx41, h, ba) to new_gtGtEs1(vx3, vx41, h, ba).

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                  ↳ QDP

                    ↳ QDPSizeChangeProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs(:(vx1010, vx1011), vx60, h) → new_gtGtEs(vx1011, vx60, h)

From the DPs we obtained the following set of size-change graphs:

new_gtGtEs(:(vx1010, vx1011), vx60, h) → new_gtGtEs(vx1011, vx60, h)
The graph contains the following edges 1 > 1, 2 >= 2, 3 >= 3

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ NumRed

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                  ↳ QDP

                  ↳ QDP

                    ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_psPs(:(vx130, vx131), vx7, h) → new_psPs(vx131, vx7, h)

From the DPs we obtained the following set of size-change graphs:

new_psPs(:(vx130, vx131), vx7, h) → new_psPs(vx131, vx7, h)
The graph contains the following edges 1 > 1, 2 >= 2, 3 >= 3