NO Termination proof of rtL-evnz.trs

Termination of the given RelTRS could be disproven:

0 RelTRS
↳1 RelTRStoRelADPProof (⇔, 0 ms)
↳2 RelADPP
↳3 RelADPDepGraphProof (⇔, 962 ms)
↳4 AND
    ↳5 RelADPP
        ↳6 RelADPReductionPairProof (⇔, 263 ms)
        ↳7 RelADPP
        ↳8 RelADPDepGraphProof (⇔, 0 ms)
        ↳9 TRUE
    ↳10 RelADPP
        ↳11 RelADPReductionPairProof (⇔, 252 ms)
        ↳12 RelADPP
        ↳13 RelADPReductionPairProof (⇔, 29 ms)
        ↳14 RelADPP
        ↳15 RelADPReductionPairProof (⇔, 28 ms)
        ↳16 RelADPP
        ↳17 RelADPReductionPairProof (⇔, 26 ms)
        ↳18 RelADPP
        ↳19 RelADPReductionPairProof (⇔, 28 ms)
        ↳20 RelADPP
        ↳21 RelADPDepGraphProof (⇔, 0 ms)
        ↳22 TRUE
    ↳23 RelADPP
        ↳24 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳25 QDP
        ↳26 MRRProof (⇔, 41 ms)
        ↳27 QDP
        ↳28 TransformationProof (⇔, 0 ms)
        ↳29 QDP
        ↳30 DependencyGraphProof (⇔, 0 ms)
        ↳31 QDP
        ↳32 NonTerminationLoopProof (⇒, 68 ms)
        ↳33 NO
    ↳34 RelADPP
        ↳35 RelADPReductionPairProof (⇔, 267 ms)
        ↳36 RelADPP
        ↳37 RelADPReductionPairProof (⇔, 19 ms)
        ↳38 RelADPP
        ↳39 RelADPDepGraphProof (⇔, 0 ms)
        ↳40 RelADPP
        ↳41 RelADPReductionPairProof (⇔, 22 ms)
        ↳42 RelADPP
        ↳43 RelADPReductionPairProof (⇔, 0 ms)
        ↳44 RelADPP
        ↳45 RelADPReductionPairProof (⇔, 22 ms)
        ↳46 RelADPP
    ↳47 RelADPP
    ↳48 RelADPP
    ↳49 RelADPP
    ↳50 RelADPP
        ↳51 RelADPReductionPairProof (⇔, 144 ms)
        ↳52 RelADPP
        ↳53 RelADPReductionPairProof (⇔, 24 ms)
        ↳54 RelADPP
        ↳55 RelADPDepGraphProof (⇔, 0 ms)
        ↳56 TRUE
    ↳57 RelADPP
    ↳58 RelADPP
        ↳59 RelADPReductionPairProof (⇔, 210 ms)
        ↳60 RelADPP
        ↳61 RelADPDepGraphProof (⇔, 0 ms)
        ↳62 TRUE
    ↳63 RelADPP
    ↳64 RelADPP
    ↳65 RelADPP
    ↳66 RelADPP
    ↳67 RelADPP
    ↳68 RelADPP
    ↳69 RelADPP
        ↳70 RelADPReductionPairProof (⇔, 260 ms)
        ↳71 RelADPP
        ↳72 RelADPDepGraphProof (⇔, 4 ms)
        ↳73 AND
            ↳74 RelADPP
                ↳75 RelADPReductionPairProof (⇔, 23 ms)
                ↳76 RelADPP
                ↳77 RelADPReductionPairProof (⇔, 26 ms)
                ↳78 RelADPP
                ↳79 RelADPDepGraphProof (⇔, 0 ms)
                ↳80 TRUE
            ↳81 RelADPP
                ↳82 RelADPReductionPairProof (⇔, 27 ms)
                ↳83 RelADPP
                ↳84 RelADPReductionPairProof (⇔, 20 ms)
                ↳85 RelADPP
                ↳86 RelADPDepGraphProof (⇔, 0 ms)
                ↳87 TRUE
            ↳88 RelADPP
                ↳89 RelADPReductionPairProof (⇔, 40 ms)
                ↳90 RelADPP
                ↳91 RelADPReductionPairProof (⇔, 22 ms)
                ↳92 RelADPP
                ↳93 RelADPDepGraphProof (⇔, 0 ms)
                ↳94 TRUE
    ↳95 RelADPP
    ↳96 RelADPP
        ↳97 RelADPReductionPairProof (⇔, 27 ms)
        ↳98 RelADPP
        ↳99 RelADPDepGraphProof (⇔, 0 ms)
        ↳100 TRUE
    ↳101 RelADPP
        ↳102 RelADPReductionPairProof (⇔, 28 ms)
        ↳103 RelADPP
        ↳104 RelADPDepGraphProof (⇔, 0 ms)
        ↳105 TRUE
    ↳106 RelADPP
        ↳107 RelADPReductionPairProof (⇔, 236 ms)
        ↳108 RelADPP
        ↳109 RelADPReductionPairProof (⇔, 45 ms)
        ↳110 RelADPP
        ↳111 RelADPReductionPairProof (⇔, 29 ms)
        ↳112 RelADPP
        ↳113 RelADPDepGraphProof (⇔, 0 ms)
        ↳114 RelADPP
        ↳115 RelADPCleverAfsProof (⇒, 0 ms)
        ↳116 QDP
        ↳117 MRRProof (⇔, 6 ms)
        ↳118 QDP
        ↳119 MRRProof (⇔, 9 ms)
        ↳120 QDP
        ↳121 PisEmptyProof (⇔, 0 ms)
        ↳122 YES
    ↳123 RelADPP
    ↳124 RelADPP
    ↳125 RelADPP
        ↳126 RelADPReductionPairProof (⇔, 28 ms)
        ↳127 RelADPP
        ↳128 RelADPReductionPairProof (⇔, 17 ms)
        ↳129 RelADPP
        ↳130 RelADPDepGraphProof (⇔, 0 ms)
        ↳131 TRUE
    ↳132 RelADPP
    ↳133 RelADPP
    ↳134 RelADPP
    ↳135 RelADPP
        ↳136 RelADPReductionPairProof (⇔, 21 ms)
        ↳137 RelADPP
        ↳138 RelADPDepGraphProof (⇔, 0 ms)
        ↳139 RelADPP
        ↳140 RelADPReductionPairProof (⇔, 37 ms)
        ↳141 RelADPP
        ↳142 RelADPReductionPairProof (⇔, 35 ms)
        ↳143 RelADPP
        ↳144 RelADPReductionPairProof (⇔, 39 ms)
        ↳145 RelADPP
        ↳146 RelADPDepGraphProof (⇔, 0 ms)
        ↳147 TRUE
    ↳148 RelADPP
    ↳149 RelADPP
    ↳150 RelADPP
    ↳151 RelADPP
        ↳152 RelADPReductionPairProof (⇔, 36 ms)
        ↳153 RelADPP
        ↳154 RelADPReductionPairProof (⇔, 13 ms)
        ↳155 RelADPP
        ↳156 RelADPDepGraphProof (⇔, 0 ms)
        ↳157 TRUE
    ↳158 RelADPP
    ↳159 RelADPP
    ↳160 RelADPP
        ↳161 RelADPReductionPairProof (⇔, 208 ms)
        ↳162 RelADPP
        ↳163 RelADPDepGraphProof (⇔, 0 ms)
        ↳164 TRUE
    ↳165 RelADPP
    ↳166 RelADPP
    ↳167 RelADPP
    ↳168 RelADPP
        ↳169 RelADPReductionPairProof (⇔, 279 ms)
        ↳170 RelADPP
        ↳171 RelADPReductionPairProof (⇔, 27 ms)
        ↳172 RelADPP
        ↳173 RelADPReductionPairProof (⇔, 13 ms)
        ↳174 RelADPP
        ↳175 RelADPDepGraphProof (⇔, 0 ms)
        ↳176 RelADPP
        ↳177 RelADPReductionPairProof (⇔, 8 ms)
        ↳178 RelADPP
        ↳179 RelADPReductionPairProof (⇔, 50 ms)
        ↳180 RelADPP
        ↳181 RelADPReductionPairProof (⇔, 52 ms)
        ↳182 RelADPP
    ↳183 RelADPP
        ↳184 RelADPReductionPairProof (⇔, 28 ms)
        ↳185 RelADPP
        ↳186 RelADPDepGraphProof (⇔, 0 ms)
        ↳187 TRUE
    ↳188 RelADPP
    ↳189 RelADPP
    ↳190 RelADPP
        ↳191 RelADPReductionPairProof (⇔, 15 ms)
        ↳192 RelADPP
        ↳193 RelADPDepGraphProof (⇔, 0 ms)
        ↳194 TRUE
    ↳195 RelADPP
    ↳196 RelADPP
    ↳197 RelADPP
    ↳198 RelADPP
    ↳199 RelADPP
    ↳200 RelADPP
        ↳201 RelADPReductionPairProof (⇔, 42 ms)
        ↳202 RelADPP
    ↳203 RelADPP
    ↳204 RelADPP
    ↳205 RelADPP
    ↳206 RelADPP
    ↳207 RelADPP
        ↳208 RelADPReductionPairProof (⇔, 29 ms)
        ↳209 RelADPP
        ↳210 RelADPDepGraphProof (⇔, 0 ms)
        ↳211 RelADPP
        ↳212 RelADPReductionPairProof (⇔, 56 ms)
        ↳213 RelADPP
        ↳214 RelADPReductionPairProof (⇔, 21 ms)
        ↳215 RelADPP
        ↳216 RelADPReductionPairProof (⇔, 8 ms)
        ↳217 RelADPP
        ↳218 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳219 QDP
        ↳220 MRRProof (⇔, 0 ms)
        ↳221 QDP
        ↳222 MRRProof (⇔, 9 ms)
        ↳223 QDP
        ↳224 PisEmptyProof (⇔, 0 ms)
        ↳225 YES
    ↳226 RelADPP
        ↳227 RelADPReductionPairProof (⇔, 44 ms)
        ↳228 RelADPP
        ↳229 RelADPDepGraphProof (⇔, 0 ms)
        ↳230 TRUE
    ↳231 RelADPP
    ↳232 RelADPP
    ↳233 RelADPP
    ↳234 RelADPP
        ↳235 RelADPReductionPairProof (⇔, 26 ms)
        ↳236 RelADPP
        ↳237 RelADPDepGraphProof (⇔, 0 ms)
        ↳238 TRUE
    ↳239 RelADPP
    ↳240 RelADPP
    ↳241 RelADPP
        ↳242 RelADPReductionPairProof (⇔, 254 ms)
        ↳243 RelADPP
        ↳244 RelADPDepGraphProof (⇔, 0 ms)
        ↳245 TRUE
    ↳246 RelADPP
    ↳247 RelADPP
        ↳248 RelADPReductionPairProof (⇔, 23 ms)
        ↳249 RelADPP
        ↳250 RelADPDepGraphProof (⇔, 0 ms)
        ↳251 TRUE
    ↳252 RelADPP
        ↳253 RelADPReductionPairProof (⇔, 17 ms)
        ↳254 RelADPP
        ↳255 RelADPDepGraphProof (⇔, 0 ms)
        ↳256 TRUE
    ↳257 RelADPP
    ↳258 RelADPP
        ↳259 RelADPReductionPairProof (⇔, 0 ms)
        ↳260 RelADPP
        ↳261 RelADPDepGraphProof (⇔, 0 ms)
        ↳262 TRUE
    ↳263 RelADPP
    ↳264 RelADPP
    ↳265 RelADPP
    ↳266 RelADPP
    ↳267 RelADPP
    ↳268 RelADPP
    ↳269 RelADPP
    ↳270 RelADPP
    ↳271 RelADPP
    ↳272 RelADPP
    ↳273 RelADPP
    ↳274 RelADPP
    ↳275 RelADPP
    ↳276 RelADPP
    ↳277 RelADPP
    ↳278 RelADPP
    ↳279 RelADPP
    ↳280 RelADPP
    ↳281 RelADPP
    ↳282 RelADPP
    ↳283 RelADPP
    ↳284 RelADPP
    ↳285 RelADPP
        ↳286 RelADPReductionPairProof (⇔, 27 ms)
        ↳287 RelADPP
        ↳288 RelADPDepGraphProof (⇔, 0 ms)
        ↳289 TRUE
    ↳290 RelADPP
    ↳291 RelADPP
    ↳292 RelADPP
    ↳293 RelADPP
    ↳294 RelADPP
    ↳295 RelADPP
        ↳296 RelADPReductionPairProof (⇔, 20 ms)
        ↳297 RelADPP
        ↳298 RelADPDepGraphProof (⇔, 0 ms)
        ↳299 TRUE
    ↳300 RelADPP
        ↳301 RelADPReductionPairProof (⇔, 22 ms)
        ↳302 RelADPP
        ↳303 RelADPReductionPairProof (⇔, 51 ms)
        ↳304 RelADPP
    ↳305 RelADPP
    ↳306 RelADPP
    ↳307 RelADPP
    ↳308 RelADPP
    ↳309 RelADPP
    ↳310 RelADPP
    ↳311 RelADPP
    ↳312 RelADPP
    ↳313 RelADPP
    ↳314 RelADPP
    ↳315 RelADPP
        ↳316 RelADPReductionPairProof (⇔, 0 ms)
        ↳317 RelADPP
        ↳318 RelADPDepGraphProof (⇔, 0 ms)
        ↳319 TRUE
    ↳320 RelADPP
    ↳321 RelADPP
    ↳322 RelADPP
        ↳323 RelADPReductionPairProof (⇔, 24 ms)
        ↳324 RelADPP
        ↳325 RelADPDepGraphProof (⇔, 0 ms)
        ↳326 TRUE
    ↳327 RelADPP
    ↳328 RelADPP
        ↳329 RelADPReductionPairProof (⇔, 34 ms)
        ↳330 RelADPP
        ↳331 RelADPDepGraphProof (⇔, 0 ms)
        ↳332 TRUE
    ↳333 RelADPP
    ↳334 RelADPP
    ↳335 RelADPP
    ↳336 RelADPP
        ↳337 RelADPReductionPairProof (⇔, 20 ms)
        ↳338 RelADPP
        ↳339 RelADPReductionPairProof (⇔, 17 ms)
        ↳340 RelADPP
        ↳341 RelADPDepGraphProof (⇔, 0 ms)
        ↳342 RelADPP
        ↳343 RelADPReductionPairProof (⇔, 23 ms)
        ↳344 RelADPP
        ↳345 RelADPReductionPairProof (⇔, 34 ms)
        ↳346 RelADPP
        ↳347 RelADPReductionPairProof (⇔, 15 ms)
        ↳348 RelADPP
        ↳349 RelADPReductionPairProof (⇔, 9 ms)
        ↳350 RelADPP
        ↳351 RelADPReductionPairProof (⇔, 2 ms)
        ↳352 RelADPP
        ↳353 RelADPReductionPairProof (⇔, 0 ms)
        ↳354 RelADPP
        ↳355 RelADPReductionPairProof (⇔, 0 ms)
        ↳356 RelADPP
        ↳357 DAbsisEmptyProof (⇔, 0 ms)
        ↳358 YES
    ↳359 RelADPP
    ↳360 RelADPP
    ↳361 RelADPP
    ↳362 RelADPP
    ↳363 RelADPP
    ↳364 RelADPP
    ↳365 RelADPP
    ↳366 RelADPP
        ↳367 RelADPReductionPairProof (⇔, 13 ms)
        ↳368 RelADPP
    ↳369 RelADPP
    ↳370 RelADPP
    ↳371 RelADPP
    ↳372 RelADPP
        ↳373 RelADPReductionPairProof (⇔, 23 ms)
        ↳374 RelADPP
    ↳375 RelADPP
        ↳376 RelADPReductionPairProof (⇔, 28 ms)
        ↳377 RelADPP
        ↳378 RelADPReductionPairProof (⇔, 23 ms)
        ↳379 RelADPP
        ↳380 RelADPDepGraphProof (⇔, 0 ms)
        ↳381 TRUE
    ↳382 RelADPP
    ↳383 RelADPP
        ↳384 RelADPReductionPairProof (⇔, 37 ms)
        ↳385 RelADPP
        ↳386 RelADPReductionPairProof (⇔, 12 ms)
        ↳387 RelADPP
        ↳388 RelADPDepGraphProof (⇔, 0 ms)
        ↳389 TRUE
    ↳390 RelADPP
    ↳391 RelADPP
        ↳392 RelADPReductionPairProof (⇔, 35 ms)
        ↳393 RelADPP
        ↳394 RelADPDepGraphProof (⇔, 0 ms)
        ↳395 TRUE
    ↳396 RelADPP
    ↳397 RelADPP
        ↳398 RelADPReductionPairProof (⇔, 37 ms)
        ↳399 RelADPP
        ↳400 RelADPReductionPairProof (⇔, 23 ms)
        ↳401 RelADPP
        ↳402 RelADPDepGraphProof (⇔, 0 ms)
        ↳403 RelADPP
        ↳404 RelADPReductionPairProof (⇔, 23 ms)
        ↳405 RelADPP
        ↳406 RelADPCleverAfsProof (⇒, 16 ms)
        ↳407 QDP
        ↳408 MRRProof (⇔, 7 ms)
        ↳409 QDP
        ↳410 MRRProof (⇔, 0 ms)
        ↳411 QDP
        ↳412 PisEmptyProof (⇔, 0 ms)
        ↳413 YES
    ↳414 RelADPP
    ↳415 RelADPP
        ↳416 RelADPReductionPairProof (⇔, 28 ms)
        ↳417 RelADPP
        ↳418 RelADPDepGraphProof (⇔, 0 ms)
        ↳419 TRUE
    ↳420 RelADPP
    ↳421 RelADPP
    ↳422 RelADPP
    ↳423 RelADPP
    ↳424 RelADPP
    ↳425 RelADPP
    ↳426 RelADPP
    ↳427 RelADPP
        ↳428 RelADPReductionPairProof (⇔, 17 ms)
        ↳429 RelADPP
        ↳430 RelADPDepGraphProof (⇔, 0 ms)
        ↳431 RelADPP
        ↳432 RelADPReductionPairProof (⇔, 63 ms)
        ↳433 RelADPP
        ↳434 RelADPReductionPairProof (⇔, 27 ms)
        ↳435 RelADPP
        ↳436 RelADPReductionPairProof (⇔, 18 ms)
        ↳437 RelADPP
        ↳438 RelADPReductionPairProof (⇔, 36 ms)
        ↳439 RelADPP
        ↳440 RelADPReductionPairProof (⇔, 34 ms)
        ↳441 RelADPP
        ↳442 RelADPReductionPairProof (⇔, 22 ms)
        ↳443 RelADPP
        ↳444 RelADPReductionPairProof (⇔, 42 ms)
        ↳445 RelADPP
        ↳446 RelADPDepGraphProof (⇔, 0 ms)
        ↳447 TRUE
    ↳448 RelADPP
    ↳449 RelADPP
    ↳450 RelADPP
        ↳451 RelADPReductionPairProof (⇔, 26 ms)
        ↳452 RelADPP
        ↳453 RelADPDepGraphProof (⇔, 0 ms)
        ↳454 TRUE
    ↳455 RelADPP
    ↳456 RelADPP
    ↳457 RelADPP
        ↳458 RelADPReductionPairProof (⇔, 18 ms)
        ↳459 RelADPP
        ↳460 RelADPReductionPairProof (⇔, 36 ms)
        ↳461 RelADPP
        ↳462 RelADPReductionPairProof (⇔, 58 ms)
        ↳463 RelADPP
        ↳464 RelADPDepGraphProof (⇔, 0 ms)
        ↳465 TRUE
    ↳466 RelADPP
    ↳467 RelADPP
    ↳468 RelADPP
        ↳469 RelADPReductionPairProof (⇔, 0 ms)
        ↳470 RelADPP
        ↳471 RelADPDepGraphProof (⇔, 0 ms)
        ↳472 TRUE
    ↳473 RelADPP
        ↳474 RelADPReductionPairProof (⇔, 34 ms)
        ↳475 RelADPP
        ↳476 RelADPDepGraphProof (⇔, 0 ms)
        ↳477 TRUE
    ↳478 RelADPP
        ↳479 RelADPReductionPairProof (⇔, 15 ms)
        ↳480 RelADPP
        ↳481 RelADPDepGraphProof (⇔, 0 ms)
        ↳482 RelADPP
        ↳483 RelADPReductionPairProof (⇔, 25 ms)
        ↳484 RelADPP
        ↳485 RelADPReductionPairProof (⇔, 29 ms)
        ↳486 RelADPP
        ↳487 RelADPReductionPairProof (⇔, 56 ms)
        ↳488 RelADPP
        ↳489 RelADPReductionPairProof (⇔, 23 ms)
        ↳490 RelADPP
        ↳491 RelADPReductionPairProof (⇔, 22 ms)
        ↳492 RelADPP
        ↳493 RelADPDepGraphProof (⇔, 0 ms)
        ↳494 TRUE
    ↳495 RelADPP
        ↳496 RelADPReductionPairProof (⇔, 19 ms)
        ↳497 RelADPP
        ↳498 RelADPDepGraphProof (⇔, 0 ms)
        ↳499 RelADPP
        ↳500 RelADPReductionPairProof (⇔, 32 ms)
        ↳501 RelADPP
        ↳502 RelADPReductionPairProof (⇔, 19 ms)
        ↳503 RelADPP
        ↳504 RelADPReductionPairProof (⇔, 43 ms)
        ↳505 RelADPP
        ↳506 RelADPReductionPairProof (⇔, 24 ms)
        ↳507 RelADPP
        ↳508 RelADPReductionPairProof (⇔, 22 ms)
        ↳509 RelADPP
        ↳510 DAbsisEmptyProof (⇔, 0 ms)
        ↳511 YES
    ↳512 RelADPP
        ↳513 RelADPReductionPairProof (⇔, 41 ms)
        ↳514 RelADPP
        ↳515 RelADPDepGraphProof (⇔, 0 ms)
        ↳516 TRUE
    ↳517 RelADPP
    ↳518 RelADPP
        ↳519 RelADPReductionPairProof (⇔, 27 ms)
        ↳520 RelADPP
        ↳521 RelADPDepGraphProof (⇔, 0 ms)
        ↳522 RelADPP
        ↳523 RelADPReductionPairProof (⇔, 70 ms)
        ↳524 RelADPP
        ↳525 RelADPReductionPairProof (⇔, 20 ms)
        ↳526 RelADPP
        ↳527 RelADPReductionPairProof (⇔, 18 ms)
        ↳528 RelADPP
        ↳529 RelADPReductionPairProof (⇔, 11 ms)
        ↳530 RelADPP
        ↳531 RelADPReductionPairProof (⇔, 23 ms)
        ↳532 RelADPP
        ↳533 RelADPReductionPairProof (⇔, 21 ms)
        ↳534 RelADPP
        ↳535 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳536 QDP
        ↳537 MRRProof (⇔, 13 ms)
        ↳538 QDP
        ↳539 MRRProof (⇔, 13 ms)
        ↳540 QDP
        ↳541 PisEmptyProof (⇔, 0 ms)
        ↳542 YES
    ↳543 RelADPP
    ↳544 RelADPP
    ↳545 RelADPP
        ↳546 RelADPReductionPairProof (⇔, 31 ms)
        ↳547 RelADPP
        ↳548 RelADPDepGraphProof (⇔, 0 ms)
        ↳549 TRUE
    ↳550 RelADPP
        ↳551 RelADPReductionPairProof (⇔, 35 ms)
        ↳552 RelADPP
        ↳553 RelADPDepGraphProof (⇔, 0 ms)
        ↳554 TRUE
    ↳555 RelADPP
    ↳556 RelADPP
        ↳557 RelADPReductionPairProof (⇔, 41 ms)
        ↳558 RelADPP
        ↳559 RelADPDepGraphProof (⇔, 0 ms)
        ↳560 TRUE
    ↳561 RelADPP
    ↳562 RelADPP
    ↳563 RelADPP
    ↳564 RelADPP
        ↳565 RelADPReductionPairProof (⇔, 25 ms)
        ↳566 RelADPP
        ↳567 RelADPDepGraphProof (⇔, 1 ms)
        ↳568 RelADPP
        ↳569 RelADPReductionPairProof (⇔, 19 ms)
        ↳570 RelADPP
        ↳571 RelADPReductionPairProof (⇔, 27 ms)
        ↳572 RelADPP
        ↳573 RelADPReductionPairProof (⇔, 21 ms)
        ↳574 RelADPP
        ↳575 RelADPReductionPairProof (⇔, 14 ms)
        ↳576 RelADPP
        ↳577 RelADPReductionPairProof (⇔, 26 ms)
        ↳578 RelADPP
        ↳579 RelADPReductionPairProof (⇔, 7 ms)
        ↳580 RelADPP
        ↳581 RelADPReductionPairProof (⇔, 24 ms)
        ↳582 RelADPP
        ↳583 RelADPDepGraphProof (⇔, 0 ms)
        ↳584 TRUE
    ↳585 RelADPP
        ↳586 RelADPReductionPairProof (⇔, 24 ms)
        ↳587 RelADPP
        ↳588 RelADPDepGraphProof (⇔, 0 ms)
        ↳589 TRUE
    ↳590 RelADPP
    ↳591 RelADPP
        ↳592 RelADPReductionPairProof (⇔, 20 ms)
        ↳593 RelADPP
        ↳594 RelADPDepGraphProof (⇔, 0 ms)
        ↳595 TRUE
    ↳596 RelADPP
    ↳597 RelADPP
        ↳598 RelADPReductionPairProof (⇔, 25 ms)
        ↳599 RelADPP
        ↳600 RelADPReductionPairProof (⇔, 23 ms)
        ↳601 RelADPP
        ↳602 RelADPDepGraphProof (⇔, 0 ms)
        ↳603 RelADPP
        ↳604 RelADPCleverAfsProof (⇒, 80 ms)
        ↳605 QDP
        ↳606 MRRProof (⇔, 7 ms)
        ↳607 QDP
        ↳608 PisEmptyProof (⇔, 0 ms)
        ↳609 YES
    ↳610 RelADPP
        ↳611 RelADPReductionPairProof (⇔, 33 ms)
        ↳612 RelADPP
        ↳613 RelADPDepGraphProof (⇔, 0 ms)
        ↳614 TRUE
    ↳615 RelADPP
        ↳616 RelADPReductionPairProof (⇔, 28 ms)
        ↳617 RelADPP
        ↳618 RelADPDepGraphProof (⇔, 0 ms)
        ↳619 AND
            ↳620 RelADPP
                ↳621 RelADPReductionPairProof (⇔, 23 ms)
                ↳622 RelADPP
                ↳623 RelADPReductionPairProof (⇔, 36 ms)
                ↳624 RelADPP
                ↳625 RelADPReductionPairProof (⇔, 9 ms)
                ↳626 RelADPP
                ↳627 RelADPReductionPairProof (⇔, 17 ms)
                ↳628 RelADPP
                ↳629 RelADPDepGraphProof (⇔, 0 ms)
                ↳630 TRUE
            ↳631 RelADPP
                ↳632 RelADPReductionPairProof (⇔, 74 ms)
                ↳633 RelADPP
                ↳634 RelADPDepGraphProof (⇔, 0 ms)
                ↳635 TRUE
            ↳636 RelADPP
                ↳637 RelADPReductionPairProof (⇔, 67 ms)
                ↳638 RelADPP
                ↳639 RelADPDepGraphProof (⇔, 0 ms)
                ↳640 TRUE
            ↳641 RelADPP
                ↳642 RelADPReductionPairProof (⇔, 32 ms)
                ↳643 RelADPP
                ↳644 RelADPDepGraphProof (⇔, 0 ms)
                ↳645 TRUE
    ↳646 RelADPP
        ↳647 RelADPReductionPairProof (⇔, 5 ms)
        ↳648 RelADPP
        ↳649 RelADPDepGraphProof (⇔, 0 ms)
        ↳650 TRUE
    ↳651 RelADPP
    ↳652 RelADPP
    ↳653 RelADPP
    ↳654 RelADPP
    ↳655 RelADPP
        ↳656 RelADPReductionPairProof (⇔, 29 ms)
        ↳657 RelADPP
        ↳658 RelADPDepGraphProof (⇔, 0 ms)
        ↳659 RelADPP
        ↳660 RelADPReductionPairProof (⇔, 22 ms)
        ↳661 RelADPP
        ↳662 RelADPReductionPairProof (⇔, 50 ms)
        ↳663 RelADPP
        ↳664 RelADPReductionPairProof (⇔, 34 ms)
        ↳665 RelADPP
        ↳666 RelADPReductionPairProof (⇔, 0 ms)
        ↳667 RelADPP
        ↳668 RelADPReductionPairProof (⇔, 4 ms)
        ↳669 RelADPP
        ↳670 RelADPReductionPairProof (⇔, 47 ms)
        ↳671 RelADPP
        ↳672 DAbsisEmptyProof (⇔, 0 ms)
        ↳673 YES
    ↳674 RelADPP
    ↳675 RelADPP
        ↳676 RelADPReductionPairProof (⇔, 69 ms)
        ↳677 RelADPP
        ↳678 RelADPDepGraphProof (⇔, 0 ms)
        ↳679 RelADPP
        ↳680 RelADPReductionPairProof (⇔, 45 ms)
        ↳681 RelADPP
        ↳682 RelADPReductionPairProof (⇔, 17 ms)
        ↳683 RelADPP
        ↳684 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳685 QDP
        ↳686 MRRProof (⇔, 0 ms)
        ↳687 QDP
        ↳688 MRRProof (⇔, 6 ms)
        ↳689 QDP
        ↳690 PisEmptyProof (⇔, 0 ms)
        ↳691 YES
    ↳692 RelADPP
        ↳693 RelADPReductionPairProof (⇔, 20 ms)
        ↳694 RelADPP
        ↳695 RelADPDepGraphProof (⇔, 0 ms)
        ↳696 TRUE
    ↳697 RelADPP
        ↳698 RelADPReductionPairProof (⇔, 72 ms)
        ↳699 RelADPP
    ↳700 RelADPP
    ↳701 RelADPP
    ↳702 RelADPP
    ↳703 RelADPP
    ↳704 RelADPP
    ↳705 RelADPP
    ↳706 RelADPP
        ↳707 RelADPReductionPairProof (⇔, 0 ms)
        ↳708 RelADPP
        ↳709 RelADPDepGraphProof (⇔, 0 ms)
        ↳710 TRUE
    ↳711 RelADPP
    ↳712 RelADPP
    ↳713 RelADPP
    ↳714 RelADPP
        ↳715 RelADPReductionPairProof (⇔, 23 ms)
        ↳716 RelADPP
        ↳717 RelADPDepGraphProof (⇔, 0 ms)
        ↳718 RelADPP
        ↳719 RelADPReductionPairProof (⇔, 13 ms)
        ↳720 RelADPP
        ↳721 RelADPReductionPairProof (⇔, 0 ms)
        ↳722 RelADPP
        ↳723 RelADPReductionPairProof (⇔, 16 ms)
        ↳724 RelADPP
        ↳725 RelADPReductionPairProof (⇔, 16 ms)
        ↳726 RelADPP
        ↳727 RelADPReductionPairProof (⇔, 45 ms)
        ↳728 RelADPP
        ↳729 DAbsisEmptyProof (⇔, 0 ms)
        ↳730 YES
    ↳731 RelADPP
    ↳732 RelADPP
    ↳733 RelADPP
    ↳734 RelADPP
    ↳735 RelADPP
        ↳736 RelADPReductionPairProof (⇔, 33 ms)
        ↳737 RelADPP
        ↳738 RelADPReductionPairProof (⇔, 26 ms)
        ↳739 RelADPP
    ↳740 RelADPP
    ↳741 RelADPP
    ↳742 RelADPP
    ↳743 RelADPP
    ↳744 RelADPP
    ↳745 RelADPP
        ↳746 RelADPReductionPairProof (⇔, 12 ms)
        ↳747 RelADPP
    ↳748 RelADPP
    ↳749 RelADPP
        ↳750 RelADPReductionPairProof (⇔, 18 ms)
        ↳751 RelADPP
    ↳752 RelADPP
    ↳753 RelADPP
        ↳754 RelADPReductionPairProof (⇔, 16 ms)
        ↳755 RelADPP
        ↳756 RelADPDepGraphProof (⇔, 0 ms)
        ↳757 TRUE
    ↳758 RelADPP
    ↳759 RelADPP
    ↳760 RelADPP
        ↳761 RelADPReductionPairProof (⇔, 14 ms)
        ↳762 RelADPP
        ↳763 RelADPDepGraphProof (⇔, 0 ms)
        ↳764 TRUE
    ↳765 RelADPP
    ↳766 RelADPP
    ↳767 RelADPP
        ↳768 RelADPReductionPairProof (⇔, 25 ms)
        ↳769 RelADPP
        ↳770 RelADPDepGraphProof (⇔, 0 ms)
        ↳771 RelADPP
        ↳772 RelADPReductionPairProof (⇔, 24 ms)
        ↳773 RelADPP
        ↳774 RelADPReductionPairProof (⇔, 22 ms)
        ↳775 RelADPP
        ↳776 RelADPReductionPairProof (⇔, 25 ms)
        ↳777 RelADPP
        ↳778 RelADPReductionPairProof (⇔, 56 ms)
        ↳779 RelADPP
        ↳780 RelADPReductionPairProof (⇔, 22 ms)
        ↳781 RelADPP
        ↳782 RelADPReductionPairProof (⇔, 27 ms)
        ↳783 RelADPP
        ↳784 DAbsisEmptyProof (⇔, 0 ms)
        ↳785 YES
    ↳786 RelADPP
    ↳787 RelADPP
        ↳788 RelADPReductionPairProof (⇔, 16 ms)
        ↳789 RelADPP
        ↳790 RelADPDepGraphProof (⇔, 0 ms)
        ↳791 RelADPP
        ↳792 RelADPReductionPairProof (⇔, 23 ms)
        ↳793 RelADPP
        ↳794 RelADPReductionPairProof (⇔, 22 ms)
        ↳795 RelADPP
        ↳796 RelADPReductionPairProof (⇔, 22 ms)
        ↳797 RelADPP
        ↳798 RelADPReductionPairProof (⇔, 24 ms)
        ↳799 RelADPP
        ↳800 RelADPDepGraphProof (⇔, 0 ms)
        ↳801 TRUE
    ↳802 RelADPP
    ↳803 RelADPP
    ↳804 RelADPP
    ↳805 RelADPP
        ↳806 RelADPReductionPairProof (⇔, 41 ms)
        ↳807 RelADPP
        ↳808 RelADPDepGraphProof (⇔, 0 ms)
        ↳809 AND
            ↳810 RelADPP
                ↳811 RelADPReductionPairProof (⇔, 41 ms)
                ↳812 RelADPP
                ↳813 RelADPReductionPairProof (⇔, 18 ms)
                ↳814 RelADPP
                ↳815 RelADPReductionPairProof (⇔, 18 ms)
                ↳816 RelADPP
                ↳817 RelADPReductionPairProof (⇔, 0 ms)
                ↳818 RelADPP
                ↳819 RelADPDepGraphProof (⇔, 0 ms)
                ↳820 TRUE
            ↳821 RelADPP
                ↳822 RelADPReductionPairProof (⇔, 78 ms)
                ↳823 RelADPP
                ↳824 RelADPDepGraphProof (⇔, 0 ms)
                ↳825 TRUE
            ↳826 RelADPP
                ↳827 RelADPReductionPairProof (⇔, 13 ms)
                ↳828 RelADPP
                ↳829 RelADPDepGraphProof (⇔, 0 ms)
                ↳830 TRUE
            ↳831 RelADPP
                ↳832 RelADPReductionPairProof (⇔, 42 ms)
                ↳833 RelADPP
                ↳834 RelADPDepGraphProof (⇔, 0 ms)
                ↳835 TRUE
    ↳836 RelADPP
    ↳837 RelADPP
    ↳838 RelADPP
    ↳839 RelADPP
    ↳840 RelADPP
    ↳841 RelADPP
        ↳842 RelADPReductionPairProof (⇔, 0 ms)
        ↳843 RelADPP
        ↳844 RelADPDepGraphProof (⇔, 0 ms)
        ↳845 RelADPP
        ↳846 RelADPReductionPairProof (⇔, 29 ms)
        ↳847 RelADPP
        ↳848 RelADPReductionPairProof (⇔, 24 ms)
        ↳849 RelADPP
        ↳850 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳851 QDP
        ↳852 MRRProof (⇔, 0 ms)
        ↳853 QDP
        ↳854 MRRProof (⇔, 0 ms)
        ↳855 QDP
        ↳856 PisEmptyProof (⇔, 0 ms)
        ↳857 YES
    ↳858 RelADPP
    ↳859 RelADPP
        ↳860 RelADPReductionPairProof (⇔, 21 ms)
        ↳861 RelADPP
        ↳862 RelADPReductionPairProof (⇔, 23 ms)
        ↳863 RelADPP
        ↳864 RelADPDepGraphProof (⇔, 0 ms)
        ↳865 TRUE
    ↳866 RelADPP
    ↳867 RelADPP
    ↳868 RelADPP
    ↳869 RelADPP
    ↳870 RelADPP
    ↳871 RelADPP
    ↳872 RelADPP
        ↳873 RelADPReductionPairProof (⇔, 2 ms)
        ↳874 RelADPP
        ↳875 RelADPDepGraphProof (⇔, 0 ms)
        ↳876 RelADPP
        ↳877 RelADPReductionPairProof (⇔, 25 ms)
        ↳878 RelADPP
        ↳879 RelADPReductionPairProof (⇔, 67 ms)
        ↳880 RelADPP
        ↳881 RelADPReductionPairProof (⇔, 16 ms)
        ↳882 RelADPP
        ↳883 RelADPReductionPairProof (⇔, 16 ms)
        ↳884 RelADPP
        ↳885 RelADPDepGraphProof (⇔, 0 ms)
        ↳886 TRUE
    ↳887 RelADPP
        ↳888 RelADPReductionPairProof (⇔, 28 ms)
        ↳889 RelADPP
        ↳890 RelADPDepGraphProof (⇔, 0 ms)
        ↳891 TRUE
    ↳892 RelADPP
        ↳893 RelADPReductionPairProof (⇔, 29 ms)
        ↳894 RelADPP
        ↳895 RelADPReductionPairProof (⇔, 23 ms)
        ↳896 RelADPP
    ↳897 RelADPP
    ↳898 RelADPP
        ↳899 RelADPReductionPairProof (⇔, 23 ms)
        ↳900 RelADPP
        ↳901 RelADPDepGraphProof (⇔, 0 ms)
        ↳902 TRUE
    ↳903 RelADPP
        ↳904 RelADPReductionPairProof (⇔, 23 ms)
        ↳905 RelADPP
        ↳906 RelADPDepGraphProof (⇔, 0 ms)
        ↳907 TRUE
    ↳908 RelADPP
    ↳909 RelADPP
    ↳910 RelADPP
    ↳911 RelADPP
    ↳912 RelADPP
        ↳913 RelADPReductionPairProof (⇔, 62 ms)
        ↳914 RelADPP
        ↳915 RelADPDepGraphProof (⇔, 0 ms)
        ↳916 TRUE
    ↳917 RelADPP
    ↳918 RelADPP
    ↳919 RelADPP
        ↳920 RelADPReductionPairProof (⇔, 222 ms)
        ↳921 RelADPP
        ↳922 RelADPReductionPairProof (⇔, 0 ms)
        ↳923 RelADPP
        ↳924 RelADPDepGraphProof (⇔, 0 ms)
        ↳925 TRUE
    ↳926 RelADPP
    ↳927 RelADPP
        ↳928 RelADPReductionPairProof (⇔, 13 ms)
        ↳929 RelADPP
        ↳930 RelADPDepGraphProof (⇔, 0 ms)
        ↳931 RelADPP
        ↳932 RelADPReductionPairProof (⇔, 0 ms)
        ↳933 RelADPP
        ↳934 RelADPReductionPairProof (⇔, 26 ms)
        ↳935 RelADPP
        ↳936 RelADPReductionPairProof (⇔, 0 ms)
        ↳937 RelADPP
        ↳938 RelADPReductionPairProof (⇔, 44 ms)
        ↳939 RelADPP
    ↳940 RelADPP
    ↳941 RelADPP
    ↳942 RelADPP
        ↳943 RelADPReductionPairProof (⇔, 37 ms)
        ↳944 RelADPP
        ↳945 RelADPDepGraphProof (⇔, 0 ms)
        ↳946 TRUE
    ↳947 RelADPP
    ↳948 RelADPP
    ↳949 RelADPP
    ↳950 RelADPP
    ↳951 RelADPP
        ↳952 RelADPReductionPairProof (⇔, 27 ms)
        ↳953 RelADPP
        ↳954 RelADPDepGraphProof (⇔, 0 ms)
        ↳955 TRUE
    ↳956 RelADPP
    ↳957 RelADPP
    ↳958 RelADPP
    ↳959 RelADPP
        ↳960 RelADPReductionPairProof (⇔, 33 ms)
        ↳961 RelADPP
        ↳962 RelADPDepGraphProof (⇔, 0 ms)
        ↳963 TRUE
    ↳964 RelADPP
    ↳965 RelADPP
    ↳966 RelADPP
    ↳967 RelADPP
    ↳968 RelADPP
    ↳969 RelADPP
        ↳970 RelADPReductionPairProof (⇔, 52 ms)
        ↳971 RelADPP
        ↳972 RelADPDepGraphProof (⇔, 0 ms)
        ↳973 RelADPP
        ↳974 RelADPReductionPairProof (⇔, 10 ms)
        ↳975 RelADPP
        ↳976 RelADPReductionPairProof (⇔, 1 ms)
        ↳977 RelADPP
        ↳978 RelADPReductionPairProof (⇔, 53 ms)
        ↳979 RelADPP
        ↳980 RelADPReductionPairProof (⇔, 15 ms)
        ↳981 RelADPP
        ↳982 RelADPReductionPairProof (⇔, 24 ms)
        ↳983 RelADPP
        ↳984 RelADPDepGraphProof (⇔, 0 ms)
        ↳985 TRUE
    ↳986 RelADPP
    ↳987 RelADPP
        ↳988 RelADPReductionPairProof (⇔, 26 ms)
        ↳989 RelADPP
        ↳990 RelADPDepGraphProof (⇔, 0 ms)
        ↳991 TRUE
    ↳992 RelADPP
    ↳993 RelADPP
    ↳994 RelADPP
    ↳995 RelADPP
    ↳996 RelADPP
    ↳997 RelADPP
    ↳998 RelADPP
    ↳999 RelADPP
    ↳1000 RelADPP
    ↳1001 RelADPP
    ↳1002 RelADPP
    ↳1003 RelADPP
    ↳1004 RelADPP
    ↳1005 RelADPP
    ↳1006 RelADPP
    ↳1007 RelADPP
    ↳1008 RelADPP
    ↳1009 RelADPP
    ↳1010 RelADPP
        ↳1011 RelADPReductionPairProof (⇔, 19 ms)
        ↳1012 RelADPP
        ↳1013 RelADPReductionPairProof (⇔, 15 ms)
        ↳1014 RelADPP
        ↳1015 RelADPDepGraphProof (⇔, 1 ms)
        ↳1016 RelADPP
        ↳1017 RelADPReductionPairProof (⇔, 16 ms)
        ↳1018 RelADPP
        ↳1019 RelADPCleverAfsProof (⇒, 14 ms)
        ↳1020 QDP
        ↳1021 MRRProof (⇔, 4 ms)
        ↳1022 QDP
        ↳1023 PisEmptyProof (⇔, 0 ms)
        ↳1024 YES
    ↳1025 RelADPP
    ↳1026 RelADPP
    ↳1027 RelADPP
    ↳1028 RelADPP
    ↳1029 RelADPP
    ↳1030 RelADPP
        ↳1031 RelADPReductionPairProof (⇔, 27 ms)
        ↳1032 RelADPP
        ↳1033 RelADPDepGraphProof (⇔, 0 ms)
        ↳1034 TRUE
    ↳1035 RelADPP
        ↳1036 RelADPReductionPairProof (⇔, 24 ms)
        ↳1037 RelADPP
        ↳1038 RelADPDepGraphProof (⇔, 0 ms)
        ↳1039 TRUE
    ↳1040 RelADPP
        ↳1041 RelADPReductionPairProof (⇔, 32 ms)
        ↳1042 RelADPP
        ↳1043 RelADPDepGraphProof (⇔, 0 ms)
        ↳1044 TRUE
    ↳1045 RelADPP
    ↳1046 RelADPP
        ↳1047 RelADPReductionPairProof (⇔, 109 ms)
        ↳1048 RelADPP
        ↳1049 RelADPDepGraphProof (⇔, 0 ms)
        ↳1050 TRUE
    ↳1051 RelADPP
        ↳1052 RelADPReductionPairProof (⇔, 18 ms)
        ↳1053 RelADPP
        ↳1054 RelADPDepGraphProof (⇔, 0 ms)
        ↳1055 RelADPP
        ↳1056 RelADPReductionPairProof (⇔, 22 ms)
        ↳1057 RelADPP
        ↳1058 RelADPReductionPairProof (⇔, 21 ms)
        ↳1059 RelADPP
        ↳1060 RelADPReductionPairProof (⇔, 0 ms)
        ↳1061 RelADPP
        ↳1062 RelADPReductionPairProof (⇔, 0 ms)
        ↳1063 RelADPP
        ↳1064 RelADPReductionPairProof (⇔, 12 ms)
        ↳1065 RelADPP
    ↳1066 RelADPP
    ↳1067 RelADPP
    ↳1068 RelADPP
        ↳1069 RelADPReductionPairProof (⇔, 49 ms)
        ↳1070 RelADPP
        ↳1071 RelADPDepGraphProof (⇔, 0 ms)
        ↳1072 RelADPP
        ↳1073 RelADPReductionPairProof (⇔, 40 ms)
        ↳1074 RelADPP
        ↳1075 RelADPReductionPairProof (⇔, 33 ms)
        ↳1076 RelADPP
        ↳1077 RelADPReductionPairProof (⇔, 32 ms)
        ↳1078 RelADPP
        ↳1079 RelADPReductionPairProof (⇔, 22 ms)
        ↳1080 RelADPP
        ↳1081 RelADPReductionPairProof (⇔, 30 ms)
        ↳1082 RelADPP
        ↳1083 RelADPReductionPairProof (⇔, 14 ms)
        ↳1084 RelADPP
        ↳1085 RelADPDepGraphProof (⇔, 0 ms)
        ↳1086 TRUE
    ↳1087 RelADPP
        ↳1088 RelADPReductionPairProof (⇔, 22 ms)
        ↳1089 RelADPP
        ↳1090 RelADPReductionPairProof (⇔, 52 ms)
        ↳1091 RelADPP
        ↳1092 RelADPDepGraphProof (⇔, 0 ms)
        ↳1093 TRUE
    ↳1094 RelADPP
        ↳1095 RelADPReductionPairProof (⇔, 24 ms)
        ↳1096 RelADPP
        ↳1097 RelADPDepGraphProof (⇔, 0 ms)
        ↳1098 TRUE
    ↳1099 RelADPP
        ↳1100 RelADPReductionPairProof (⇔, 0 ms)
        ↳1101 RelADPP
        ↳1102 RelADPDepGraphProof (⇔, 0 ms)
        ↳1103 RelADPP
        ↳1104 RelADPReductionPairProof (⇔, 0 ms)
        ↳1105 RelADPP
        ↳1106 RelADPReductionPairProof (⇔, 27 ms)
        ↳1107 RelADPP
        ↳1108 RelADPReductionPairProof (⇔, 0 ms)
        ↳1109 RelADPP
        ↳1110 RelADPReductionPairProof (⇔, 22 ms)
        ↳1111 RelADPP
        ↳1112 RelADPReductionPairProof (⇔, 23 ms)
        ↳1113 RelADPP
        ↳1114 RelADPReductionPairProof (⇔, 53 ms)
        ↳1115 RelADPP
        ↳1116 RelADPDepGraphProof (⇔, 0 ms)
        ↳1117 TRUE
    ↳1118 RelADPP
    ↳1119 RelADPP
        ↳1120 RelADPReductionPairProof (⇔, 39 ms)
        ↳1121 RelADPP
        ↳1122 RelADPReductionPairProof (⇔, 5 ms)
        ↳1123 RelADPP
        ↳1124 RelADPDepGraphProof (⇔, 0 ms)
        ↳1125 RelADPP
        ↳1126 RelADPReductionPairProof (⇔, 26 ms)
        ↳1127 RelADPP
        ↳1128 RelADPReductionPairProof (⇔, 1 ms)
        ↳1129 RelADPP
        ↳1130 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳1131 QDP
        ↳1132 MRRProof (⇔, 10 ms)
        ↳1133 QDP
        ↳1134 PisEmptyProof (⇔, 0 ms)
        ↳1135 YES
    ↳1136 RelADPP
    ↳1137 RelADPP
    ↳1138 RelADPP
        ↳1139 RelADPReductionPairProof (⇔, 6 ms)
        ↳1140 RelADPP
        ↳1141 RelADPDepGraphProof (⇔, 0 ms)
        ↳1142 RelADPP
        ↳1143 RelADPReductionPairProof (⇔, 32 ms)
        ↳1144 RelADPP
        ↳1145 RelADPReductionPairProof (⇔, 28 ms)
        ↳1146 RelADPP
        ↳1147 RelADPReductionPairProof (⇔, 0 ms)
        ↳1148 RelADPP
        ↳1149 RelADPReductionPairProof (⇔, 22 ms)
        ↳1150 RelADPP
        ↳1151 RelADPReductionPairProof (⇔, 14 ms)
        ↳1152 RelADPP
        ↳1153 RelADPDepGraphProof (⇔, 0 ms)
        ↳1154 TRUE
    ↳1155 RelADPP
        ↳1156 RelADPReductionPairProof (⇔, 46 ms)
        ↳1157 RelADPP
        ↳1158 RelADPDepGraphProof (⇔, 1 ms)
        ↳1159 RelADPP
        ↳1160 RelADPReductionPairProof (⇔, 0 ms)
        ↳1161 RelADPP
        ↳1162 RelADPReductionPairProof (⇔, 34 ms)
        ↳1163 RelADPP
        ↳1164 RelADPReductionPairProof (⇔, 29 ms)
        ↳1165 RelADPP
        ↳1166 RelADPReductionPairProof (⇔, 32 ms)
        ↳1167 RelADPP
        ↳1168 RelADPReductionPairProof (⇔, 42 ms)
        ↳1169 RelADPP
        ↳1170 RelADPReductionPairProof (⇔, 32 ms)
        ↳1171 RelADPP
        ↳1172 RelADPReductionPairProof (⇔, 30 ms)
        ↳1173 RelADPP
        ↳1174 DAbsisEmptyProof (⇔, 0 ms)
        ↳1175 YES
    ↳1176 RelADPP
        ↳1177 RelADPReductionPairProof (⇔, 53 ms)
        ↳1178 RelADPP
        ↳1179 RelADPReductionPairProof (⇔, 54 ms)
        ↳1180 RelADPP
        ↳1181 RelADPDepGraphProof (⇔, 0 ms)
        ↳1182 TRUE
    ↳1183 RelADPP
        ↳1184 RelADPReductionPairProof (⇔, 54 ms)
        ↳1185 RelADPP
        ↳1186 RelADPDepGraphProof (⇔, 0 ms)
        ↳1187 RelADPP
        ↳1188 RelADPReductionPairProof (⇔, 54 ms)
        ↳1189 RelADPP
        ↳1190 RelADPReductionPairProof (⇔, 33 ms)
        ↳1191 RelADPP
        ↳1192 RelADPReductionPairProof (⇔, 0 ms)
        ↳1193 RelADPP
        ↳1194 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳1195 QDP
        ↳1196 MRRProof (⇔, 11 ms)
        ↳1197 QDP
        ↳1198 MRRProof (⇔, 0 ms)
        ↳1199 QDP
        ↳1200 PisEmptyProof (⇔, 0 ms)
        ↳1201 YES
    ↳1202 RelADPP
    ↳1203 RelADPP
        ↳1204 RelADPReductionPairProof (⇔, 72 ms)
        ↳1205 RelADPP
        ↳1206 RelADPReductionPairProof (⇔, 26 ms)
        ↳1207 RelADPP
        ↳1208 RelADPDepGraphProof (⇔, 0 ms)
        ↳1209 RelADPP
        ↳1210 RelADPReductionPairProof (⇔, 20 ms)
        ↳1211 RelADPP
        ↳1212 RelADPReductionPairProof (⇔, 25 ms)
        ↳1213 RelADPP
        ↳1214 RelADPReductionPairProof (⇔, 16 ms)
        ↳1215 RelADPP
        ↳1216 RelADPReductionPairProof (⇔, 25 ms)
        ↳1217 RelADPP
    ↳1218 RelADPP
    ↳1219 RelADPP
        ↳1220 RelADPReductionPairProof (⇔, 32 ms)
        ↳1221 RelADPP
        ↳1222 RelADPDepGraphProof (⇔, 0 ms)
        ↳1223 TRUE
    ↳1224 RelADPP
    ↳1225 RelADPP
    ↳1226 RelADPP
        ↳1227 RelADPReductionPairProof (⇔, 44 ms)
        ↳1228 RelADPP
        ↳1229 RelADPDepGraphProof (⇔, 0 ms)
        ↳1230 RelADPP
        ↳1231 RelADPReductionPairProof (⇔, 48 ms)
        ↳1232 RelADPP
        ↳1233 RelADPReductionPairProof (⇔, 39 ms)
        ↳1234 RelADPP
        ↳1235 RelADPReductionPairProof (⇔, 32 ms)
        ↳1236 RelADPP
        ↳1237 RelADPReductionPairProof (⇔, 39 ms)
        ↳1238 RelADPP
        ↳1239 RelADPReductionPairProof (⇔, 35 ms)
        ↳1240 RelADPP
        ↳1241 RelADPReductionPairProof (⇔, 53 ms)
        ↳1242 RelADPP
        ↳1243 RelADPDepGraphProof (⇔, 0 ms)
        ↳1244 TRUE
    ↳1245 RelADPP
    ↳1246 RelADPP
    ↳1247 RelADPP
        ↳1248 RelADPReductionPairProof (⇔, 24 ms)
        ↳1249 RelADPP
        ↳1250 RelADPReductionPairProof (⇔, 0 ms)
        ↳1251 RelADPP
        ↳1252 RelADPReductionPairProof (⇔, 27 ms)
        ↳1253 RelADPP
        ↳1254 RelADPDepGraphProof (⇔, 0 ms)
        ↳1255 TRUE
    ↳1256 RelADPP
    ↳1257 RelADPP
    ↳1258 RelADPP
        ↳1259 RelADPReductionPairProof (⇔, 53 ms)
        ↳1260 RelADPP
        ↳1261 RelADPDepGraphProof (⇔, 0 ms)
        ↳1262 RelADPP
        ↳1263 RelADPReductionPairProof (⇔, 23 ms)
        ↳1264 RelADPP
        ↳1265 RelADPReductionPairProof (⇔, 0 ms)
        ↳1266 RelADPP
        ↳1267 RelADPReductionPairProof (⇔, 22 ms)
        ↳1268 RelADPP
        ↳1269 RelADPReductionPairProof (⇔, 47 ms)
        ↳1270 RelADPP
        ↳1271 RelADPDepGraphProof (⇔, 0 ms)
        ↳1272 TRUE
    ↳1273 RelADPP
    ↳1274 RelADPP
        ↳1275 RelADPReductionPairProof (⇔, 24 ms)
        ↳1276 RelADPP
        ↳1277 RelADPDepGraphProof (⇔, 0 ms)
        ↳1278 TRUE
    ↳1279 RelADPP
    ↳1280 RelADPP
    ↳1281 RelADPP
        ↳1282 RelADPReductionPairProof (⇔, 52 ms)
        ↳1283 RelADPP
        ↳1284 RelADPDepGraphProof (⇔, 0 ms)
        ↳1285 AND
            ↳1286 RelADPP
                ↳1287 RelADPReductionPairProof (⇔, 37 ms)
                ↳1288 RelADPP
                ↳1289 RelADPDepGraphProof (⇔, 0 ms)
                ↳1290 TRUE
            ↳1291 RelADPP
                ↳1292 RelADPReductionPairProof (⇔, 39 ms)
                ↳1293 RelADPP
                ↳1294 RelADPDepGraphProof (⇔, 0 ms)
                ↳1295 TRUE
            ↳1296 RelADPP
                ↳1297 RelADPReductionPairProof (⇔, 61 ms)
                ↳1298 RelADPP
                ↳1299 RelADPDepGraphProof (⇔, 0 ms)
                ↳1300 TRUE
    ↳1301 RelADPP
    ↳1302 RelADPP
    ↳1303 RelADPP
    ↳1304 RelADPP
        ↳1305 RelADPReductionPairProof (⇔, 27 ms)
        ↳1306 RelADPP
        ↳1307 RelADPDepGraphProof (⇔, 0 ms)
        ↳1308 TRUE
    ↳1309 RelADPP
    ↳1310 RelADPP
        ↳1311 RelADPReductionPairProof (⇔, 31 ms)
        ↳1312 RelADPP
        ↳1313 RelADPDepGraphProof (⇔, 0 ms)
        ↳1314 RelADPP
        ↳1315 RelADPReductionPairProof (⇔, 66 ms)
        ↳1316 RelADPP
        ↳1317 RelADPReductionPairProof (⇔, 24 ms)
        ↳1318 RelADPP
        ↳1319 RelADPReductionPairProof (⇔, 66 ms)
        ↳1320 RelADPP
        ↳1321 RelADPReductionPairProof (⇔, 15 ms)
        ↳1322 RelADPP
        ↳1323 DAbsisEmptyProof (⇔, 0 ms)
        ↳1324 YES
    ↳1325 RelADPP
    ↳1326 RelADPP
    ↳1327 RelADPP
    ↳1328 RelADPP
    ↳1329 RelADPP
    ↳1330 RelADPP
        ↳1331 RelADPReductionPairProof (⇔, 23 ms)
        ↳1332 RelADPP
        ↳1333 RelADPDepGraphProof (⇔, 0 ms)
        ↳1334 RelADPP
        ↳1335 RelADPReductionPairProof (⇔, 25 ms)
        ↳1336 RelADPP
        ↳1337 RelADPReductionPairProof (⇔, 16 ms)
        ↳1338 RelADPP
    ↳1339 RelADPP
    ↳1340 RelADPP
    ↳1341 RelADPP
        ↳1342 RelADPReductionPairProof (⇔, 7 ms)
        ↳1343 RelADPP
        ↳1344 RelADPDepGraphProof (⇔, 0 ms)
        ↳1345 TRUE
    ↳1346 RelADPP
    ↳1347 RelADPP
    ↳1348 RelADPP
    ↳1349 RelADPP
    ↳1350 RelADPP
    ↳1351 RelADPP
        ↳1352 RelADPReductionPairProof (⇔, 29 ms)
        ↳1353 RelADPP
        ↳1354 RelADPDepGraphProof (⇔, 0 ms)
        ↳1355 TRUE
    ↳1356 RelADPP
    ↳1357 RelADPP
    ↳1358 RelADPP
    ↳1359 RelADPP
        ↳1360 RelADPReductionPairProof (⇔, 50 ms)
        ↳1361 RelADPP
        ↳1362 RelADPReductionPairProof (⇔, 6 ms)
        ↳1363 RelADPP
        ↳1364 RelADPDepGraphProof (⇔, 0 ms)
        ↳1365 TRUE
    ↳1366 RelADPP
        ↳1367 RelADPReductionPairProof (⇔, 29 ms)
        ↳1368 RelADPP
        ↳1369 RelADPDepGraphProof (⇔, 1 ms)
        ↳1370 RelADPP
        ↳1371 RelADPReductionPairProof (⇔, 9 ms)
        ↳1372 RelADPP
        ↳1373 RelADPReductionPairProof (⇔, 29 ms)
        ↳1374 RelADPP
        ↳1375 RelADPReductionPairProof (⇔, 21 ms)
        ↳1376 RelADPP
        ↳1377 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳1378 QDP
        ↳1379 MRRProof (⇔, 0 ms)
        ↳1380 QDP
        ↳1381 PisEmptyProof (⇔, 0 ms)
        ↳1382 YES
    ↳1383 RelADPP
    ↳1384 RelADPP
        ↳1385 RelADPReductionPairProof (⇔, 0 ms)
        ↳1386 RelADPP
        ↳1387 RelADPReductionPairProof (⇔, 23 ms)
        ↳1388 RelADPP
        ↳1389 RelADPDepGraphProof (⇔, 0 ms)
        ↳1390 RelADPP
        ↳1391 RelADPReductionPairProof (⇔, 14 ms)
        ↳1392 RelADPP
        ↳1393 RelADPDepGraphProof (⇔, 0 ms)
        ↳1394 TRUE
    ↳1395 RelADPP
    ↳1396 RelADPP
    ↳1397 RelADPP
    ↳1398 RelADPP
        ↳1399 RelADPReductionPairProof (⇔, 23 ms)
        ↳1400 RelADPP
        ↳1401 RelADPDepGraphProof (⇔, 0 ms)
        ↳1402 TRUE
    ↳1403 RelADPP
    ↳1404 RelADPP
    ↳1405 RelADPP
    ↳1406 RelADPP
        ↳1407 RelADPReductionPairProof (⇔, 17 ms)
        ↳1408 RelADPP
        ↳1409 RelADPReductionPairProof (⇔, 16 ms)
        ↳1410 RelADPP
        ↳1411 RelADPReductionPairProof (⇔, 13 ms)
        ↳1412 RelADPP
    ↳1413 RelADPP
    ↳1414 RelADPP
        ↳1415 RelADPReductionPairProof (⇔, 34 ms)
        ↳1416 RelADPP
        ↳1417 RelADPDepGraphProof (⇔, 0 ms)
        ↳1418 AND
            ↳1419 RelADPP
                ↳1420 RelADPReductionPairProof (⇔, 22 ms)
                ↳1421 RelADPP
                ↳1422 RelADPDepGraphProof (⇔, 0 ms)
                ↳1423 TRUE
            ↳1424 RelADPP
                ↳1425 RelADPReductionPairProof (⇔, 21 ms)
                ↳1426 RelADPP
                ↳1427 RelADPDepGraphProof (⇔, 0 ms)
                ↳1428 TRUE
            ↳1429 RelADPP
                ↳1430 RelADPReductionPairProof (⇔, 1 ms)
                ↳1431 RelADPP
                ↳1432 RelADPDepGraphProof (⇔, 0 ms)
                ↳1433 TRUE
    ↳1434 RelADPP
    ↳1435 RelADPP
        ↳1436 RelADPReductionPairProof (⇔, 26 ms)
        ↳1437 RelADPP
        ↳1438 RelADPDepGraphProof (⇔, 0 ms)
        ↳1439 TRUE
    ↳1440 RelADPP
        ↳1441 RelADPReductionPairProof (⇔, 0 ms)
        ↳1442 RelADPP
        ↳1443 RelADPDepGraphProof (⇔, 0 ms)
        ↳1444 TRUE
    ↳1445 RelADPP
    ↳1446 RelADPP
    ↳1447 RelADPP
    ↳1448 RelADPP
    ↳1449 RelADPP
    ↳1450 RelADPP
        ↳1451 RelADPReductionPairProof (⇔, 7 ms)
        ↳1452 RelADPP
    ↳1453 RelADPP
    ↳1454 RelADPP
        ↳1455 RelADPReductionPairProof (⇔, 29 ms)
        ↳1456 RelADPP
        ↳1457 RelADPDepGraphProof (⇔, 0 ms)
        ↳1458 TRUE
    ↳1459 RelADPP
    ↳1460 RelADPP
    ↳1461 RelADPP
    ↳1462 RelADPP
    ↳1463 RelADPP
    ↳1464 RelADPP
    ↳1465 RelADPP
        ↳1466 RelADPReductionPairProof (⇔, 20 ms)
        ↳1467 RelADPP
        ↳1468 RelADPDepGraphProof (⇔, 0 ms)
        ↳1469 RelADPP
        ↳1470 RelADPReductionPairProof (⇔, 15 ms)
        ↳1471 RelADPP
        ↳1472 RelADPReductionPairProof (⇔, 19 ms)
        ↳1473 RelADPP
        ↳1474 RelADPReductionPairProof (⇔, 52 ms)
        ↳1475 RelADPP
        ↳1476 RelADPReductionPairProof (⇔, 0 ms)
        ↳1477 RelADPP
        ↳1478 DAbsisEmptyProof (⇔, 0 ms)
        ↳1479 YES
    ↳1480 RelADPP
    ↳1481 RelADPP
        ↳1482 RelADPReductionPairProof (⇔, 30 ms)
        ↳1483 RelADPP
        ↳1484 RelADPDepGraphProof (⇔, 0 ms)
        ↳1485 TRUE
    ↳1486 RelADPP
    ↳1487 RelADPP
    ↳1488 RelADPP
    ↳1489 RelADPP
    ↳1490 RelADPP
        ↳1491 RelADPReductionPairProof (⇔, 22 ms)
        ↳1492 RelADPP
        ↳1493 RelADPDepGraphProof (⇔, 0 ms)
        ↳1494 AND
            ↳1495 RelADPP
                ↳1496 RelADPReductionPairProof (⇔, 23 ms)
                ↳1497 RelADPP
                ↳1498 RelADPDepGraphProof (⇔, 0 ms)
                ↳1499 TRUE
            ↳1500 RelADPP
                ↳1501 RelADPReductionPairProof (⇔, 18 ms)
                ↳1502 RelADPP
                ↳1503 RelADPDepGraphProof (⇔, 0 ms)
                ↳1504 TRUE
            ↳1505 RelADPP
                ↳1506 RelADPReductionPairProof (⇔, 19 ms)
                ↳1507 RelADPP
                ↳1508 RelADPDepGraphProof (⇔, 0 ms)
                ↳1509 TRUE
    ↳1510 RelADPP
    ↳1511 RelADPP
        ↳1512 RelADPReductionPairProof (⇔, 21 ms)
        ↳1513 RelADPP
    ↳1514 RelADPP
    ↳1515 RelADPP
        ↳1516 RelADPReductionPairProof (⇔, 50 ms)
        ↳1517 RelADPP
    ↳1518 RelADPP
    ↳1519 RelADPP
    ↳1520 RelADPP
    ↳1521 RelADPP
        ↳1522 RelADPReductionPairProof (⇔, 20 ms)
        ↳1523 RelADPP
    ↳1524 RelADPP
    ↳1525 RelADPP
    ↳1526 RelADPP
    ↳1527 RelADPP
        ↳1528 RelADPReductionPairProof (⇔, 1 ms)
        ↳1529 RelADPP
        ↳1530 RelADPDepGraphProof (⇔, 0 ms)
        ↳1531 TRUE
    ↳1532 RelADPP
    ↳1533 RelADPP
    ↳1534 RelADPP
    ↳1535 RelADPP
        ↳1536 RelADPReductionPairProof (⇔, 39 ms)
        ↳1537 RelADPP
        ↳1538 RelADPDepGraphProof (⇔, 0 ms)
        ↳1539 TRUE
    ↳1540 RelADPP
    ↳1541 RelADPP
    ↳1542 RelADPP
        ↳1543 RelADPReductionPairProof (⇔, 21 ms)
        ↳1544 RelADPP
        ↳1545 RelADPDepGraphProof (⇔, 0 ms)
        ↳1546 TRUE
    ↳1547 RelADPP
    ↳1548 RelADPP
    ↳1549 RelADPP
    ↳1550 RelADPP
    ↳1551 RelADPP
    ↳1552 RelADPP
    ↳1553 RelADPP
    ↳1554 RelADPP
    ↳1555 RelADPP
        ↳1556 RelADPReductionPairProof (⇔, 28 ms)
        ↳1557 RelADPP
        ↳1558 RelADPDepGraphProof (⇔, 0 ms)
        ↳1559 RelADPP
        ↳1560 RelADPReductionPairProof (⇔, 30 ms)
        ↳1561 RelADPP
        ↳1562 RelADPReductionPairProof (⇔, 26 ms)
        ↳1563 RelADPP
        ↳1564 RelADPReductionPairProof (⇔, 33 ms)
        ↳1565 RelADPP
        ↳1566 RelADPReductionPairProof (⇔, 31 ms)
        ↳1567 RelADPP
        ↳1568 RelADPDepGraphProof (⇔, 0 ms)
        ↳1569 TRUE
    ↳1570 RelADPP
    ↳1571 RelADPP
        ↳1572 RelADPReductionPairProof (⇔, 30 ms)
        ↳1573 RelADPP
        ↳1574 RelADPDepGraphProof (⇔, 0 ms)
        ↳1575 TRUE
    ↳1576 RelADPP
    ↳1577 RelADPP
    ↳1578 RelADPP
    ↳1579 RelADPP
    ↳1580 RelADPP
    ↳1581 RelADPP
    ↳1582 RelADPP
    ↳1583 RelADPP
    ↳1584 RelADPP
    ↳1585 RelADPP
    ↳1586 RelADPP
    ↳1587 RelADPP
        ↳1588 RelADPReductionPairProof (⇔, 33 ms)
        ↳1589 RelADPP
        ↳1590 RelADPDepGraphProof (⇔, 0 ms)
        ↳1591 TRUE
    ↳1592 RelADPP
    ↳1593 RelADPP
    ↳1594 RelADPP
        ↳1595 RelADPReductionPairProof (⇔, 22 ms)
        ↳1596 RelADPP
        ↳1597 RelADPDepGraphProof (⇔, 0 ms)
        ↳1598 RelADPP
        ↳1599 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳1600 QDP
        ↳1601 MRRProof (⇔, 3 ms)
        ↳1602 QDP
        ↳1603 PisEmptyProof (⇔, 0 ms)
        ↳1604 YES
    ↳1605 RelADPP
    ↳1606 RelADPP
        ↳1607 RelADPReductionPairProof (⇔, 24 ms)
        ↳1608 RelADPP
    ↳1609 RelADPP
    ↳1610 RelADPP
    ↳1611 RelADPP
    ↳1612 RelADPP
        ↳1613 RelADPReductionPairProof (⇔, 38 ms)
        ↳1614 RelADPP
        ↳1615 RelADPDepGraphProof (⇔, 0 ms)
        ↳1616 TRUE
    ↳1617 RelADPP
    ↳1618 RelADPP
    ↳1619 RelADPP
    ↳1620 RelADPP
    ↳1621 RelADPP
        ↳1622 RelADPReductionPairProof (⇔, 39 ms)
        ↳1623 RelADPP
        ↳1624 RelADPDepGraphProof (⇔, 0 ms)
        ↳1625 RelADPP
        ↳1626 RelADPDerelatifyingProof (⇔, 0 ms)
        ↳1627 QDP
        ↳1628 MRRProof (⇔, 20 ms)
        ↳1629 QDP
        ↳1630 PisEmptyProof (⇔, 0 ms)
        ↳1631 YES
    ↳1632 RelADPP
    ↳1633 RelADPP
        ↳1634 RelADPReductionPairProof (⇔, 50 ms)
        ↳1635 RelADPP
    ↳1636 RelADPP
    ↳1637 RelADPP
    ↳1638 RelADPP
    ↳1639 RelADPP
    ↳1640 RelADPP
    ↳1641 RelADPP
    ↳1642 RelADPP
        ↳1643 RelADPReductionPairProof (⇔, 55 ms)
        ↳1644 RelADPP
        ↳1645 RelADPDepGraphProof (⇔, 0 ms)
        ↳1646 TRUE
    ↳1647 RelADPP
        ↳1648 RelADPReductionPairProof (⇔, 7 ms)
        ↳1649 RelADPP
        ↳1650 RelADPDepGraphProof (⇔, 0 ms)
        ↳1651 RelADPP
        ↳1652 RelADPReductionPairProof (⇔, 18 ms)
        ↳1653 RelADPP
        ↳1654 RelADPReductionPairProof (⇔, 19 ms)
        ↳1655 RelADPP
        ↳1656 RelADPReductionPairProof (⇔, 23 ms)
        ↳1657 RelADPP
        ↳1658 RelADPReductionPairProof (⇔, 0 ms)
        ↳1659 RelADPP
        ↳1660 RelADPReductionPairProof (⇔, 62 ms)
        ↳1661 RelADPP
        ↳1662 RelADPDepGraphProof (⇔, 0 ms)
        ↳1663 TRUE
    ↳1664 RelADPP
    ↳1665 RelADPP
    ↳1666 RelADPP
        ↳1667 RelADPReductionPairProof (⇔, 24 ms)
        ↳1668 RelADPP
        ↳1669 RelADPDepGraphProof (⇔, 0 ms)
        ↳1670 RelADPP
        ↳1671 RelADPReductionPairProof (⇔, 42 ms)
        ↳1672 RelADPP
        ↳1673 RelADPDepGraphProof (⇔, 0 ms)
        ↳1674 TRUE
    ↳1675 RelADPP
    ↳1676 RelADPP
        ↳1677 RelADPReductionPairProof (⇔, 28 ms)
        ↳1678 RelADPP
        ↳1679 RelADPDepGraphProof (⇔, 1 ms)
        ↳1680 AND
            ↳1681 RelADPP
                ↳1682 RelADPReductionPairProof (⇔, 19 ms)
                ↳1683 RelADPP
                ↳1684 RelADPDepGraphProof (⇔, 0 ms)
                ↳1685 TRUE
            ↳1686 RelADPP
                ↳1687 RelADPReductionPairProof (⇔, 20 ms)
                ↳1688 RelADPP
                ↳1689 RelADPDepGraphProof (⇔, 0 ms)
                ↳1690 TRUE
            ↳1691 RelADPP
                ↳1692 RelADPReductionPairProof (⇔, 25 ms)
                ↳1693 RelADPP
                ↳1694 RelADPDepGraphProof (⇔, 0 ms)
                ↳1695 TRUE
    ↳1696 RelADPP
    ↳1697 RelADPP
        ↳1698 RelADPReductionPairProof (⇔, 24 ms)
        ↳1699 RelADPP
        ↳1700 RelADPDepGraphProof (⇔, 0 ms)
        ↳1701 AND
            ↳1702 RelADPP
                ↳1703 RelADPReductionPairProof (⇔, 22 ms)
                ↳1704 RelADPP
                ↳1705 RelADPDepGraphProof (⇔, 0 ms)
                ↳1706 TRUE
            ↳1707 RelADPP
                ↳1708 RelADPReductionPairProof (⇔, 26 ms)
                ↳1709 RelADPP
                ↳1710 RelADPDepGraphProof (⇔, 0 ms)
                ↳1711 TRUE
            ↳1712 RelADPP
                ↳1713 RelADPReductionPairProof (⇔, 54 ms)
                ↳1714 RelADPP
                ↳1715 RelADPDepGraphProof (⇔, 0 ms)
                ↳1716 TRUE
    ↳1717 RelADPP
    ↳1718 RelADPP
        ↳1719 RelADPReductionPairProof (⇔, 26 ms)
        ↳1720 RelADPP
    ↳1721 RelADPP
    ↳1722 RelADPP
    ↳1723 RelADPP
    ↳1724 RelADPP
        ↳1725 RelADPReductionPairProof (⇔, 16 ms)
        ↳1726 RelADPP
        ↳1727 RelADPDepGraphProof (⇔, 0 ms)
        ↳1728 TRUE
    ↳1729 RelADPP
    ↳1730 RelADPP
    ↳1731 RelADPP
    ↳1732 RelADPP
    ↳1733 RelADPP
        ↳1734 RelADPReductionPairProof (⇔, 25 ms)
        ↳1735 RelADPP
        ↳1736 RelADPReductionPairProof (⇔, 66 ms)
        ↳1737 RelADPP
        ↳1738 RelADPReductionPairProof (⇔, 17 ms)
        ↳1739 RelADPP
        ↳1740 RelADPDepGraphProof (⇔, 0 ms)
        ↳1741 TRUE
    ↳1742 RelADPP
    ↳1743 RelADPP
    ↳1744 RelADPP
    ↳1745 RelADPP
    ↳1746 RelADPP
    ↳1747 RelADPP
    ↳1748 RelADPP
    ↳1749 RelADPP
    ↳1750 RelADPP
    ↳1751 RelADPP
    ↳1752 RelADPP
        ↳1753 RelADPReductionPairProof (⇔, 0 ms)
        ↳1754 RelADPP
    ↳1755 RelADPP
        ↳1756 RelADPReductionPairProof (⇔, 36 ms)
        ↳1757 RelADPP
        ↳1758 RelADPReductionPairProof (⇔, 25 ms)
        ↳1759 RelADPP
        ↳1760 RelADPReductionPairProof (⇔, 63 ms)
        ↳1761 RelADPP
        ↳1762 RelADPDepGraphProof (⇔, 0 ms)
        ↳1763 AND
            ↳1764 RelADPP
                ↳1765 RelADPCleverAfsProof (⇒, 29 ms)
                ↳1766 QDP
                ↳1767 MRRProof (⇔, 0 ms)
                ↳1768 QDP
                ↳1769 PisEmptyProof (⇔, 0 ms)
                ↳1770 YES
            ↳1771 RelADPP
                ↳1772 RelADPReductionPairProof (⇔, 20 ms)
                ↳1773 RelADPP
                ↳1774 RelADPReductionPairProof (⇔, 13 ms)
                ↳1775 RelADPP
                ↳1776 RelADPReductionPairProof (⇔, 22 ms)
                ↳1777 RelADPP
                ↳1778 RelADPDepGraphProof (⇔, 0 ms)
                ↳1779 TRUE
            ↳1780 RelADPP
                ↳1781 RelADPReductionPairProof (⇔, 20 ms)
                ↳1782 RelADPP
                ↳1783 RelADPReductionPairProof (⇔, 24 ms)
                ↳1784 RelADPP
                ↳1785 RelADPReductionPairProof (⇔, 13 ms)
                ↳1786 RelADPP
                ↳1787 RelADPDepGraphProof (⇔, 0 ms)
                ↳1788 TRUE
            ↳1789 RelADPP
                ↳1790 RelADPReductionPairProof (⇔, 0 ms)
                ↳1791 RelADPP
                ↳1792 RelADPReductionPairProof (⇔, 53 ms)
                ↳1793 RelADPP
                ↳1794 RelADPReductionPairProof (⇔, 12 ms)
                ↳1795 RelADPP
                ↳1796 RelADPDepGraphProof (⇔, 0 ms)
                ↳1797 TRUE
    ↳1798 RelADPP
    ↳1799 RelADPP
        ↳1800 RelADPReductionPairProof (⇔, 26 ms)
        ↳1801 RelADPP
        ↳1802 RelADPDepGraphProof (⇔, 0 ms)
        ↳1803 TRUE
    ↳1804 RelADPP
        ↳1805 RelADPReductionPairProof (⇔, 12 ms)
        ↳1806 RelADPP
    ↳1807 RelADPP
        ↳1808 RelADPReductionPairProof (⇔, 21 ms)
        ↳1809 RelADPP
        ↳1810 RelADPDepGraphProof (⇔, 0 ms)
        ↳1811 TRUE
    ↳1812 RelADPP
    ↳1813 RelADPP
        ↳1814 RelADPReductionPairProof (⇔, 45 ms)
        ↳1815 RelADPP
        ↳1816 RelADPReductionPairProof (⇔, 21 ms)
        ↳1817 RelADPP
        ↳1818 RelADPDepGraphProof (⇔, 0 ms)
        ↳1819 TRUE
    ↳1820 RelADPP
        ↳1821 RelADPReductionPairProof (⇔, 44 ms)
        ↳1822 RelADPP
        ↳1823 RelADPDepGraphProof (⇔, 0 ms)
        ↳1824 TRUE
    ↳1825 RelADPP
    ↳1826 RelADPP
    ↳1827 RelADPP
        ↳1828 RelADPReductionPairProof (⇔, 25 ms)
        ↳1829 RelADPP
        ↳1830 RelADPReductionPairProof (⇔, 27 ms)
        ↳1831 RelADPP
        ↳1832 RelADPDepGraphProof (⇔, 0 ms)
        ↳1833 TRUE
    ↳1834 RelADPP
    ↳1835 RelADPP
    ↳1836 RelADPP
        ↳1837 RelADPReductionPairProof (⇔, 17 ms)
        ↳1838 RelADPP
        ↳1839 RelADPDepGraphProof (⇔, 0 ms)
        ↳1840 TRUE
    ↳1841 RelADPP
    ↳1842 RelADPP
    ↳1843 RelADPP
    ↳1844 RelADPP
    ↳1845 RelADPP
    ↳1846 RelADPP
    ↳1847 RelADPP
        ↳1848 RelADPReductionPairProof (⇔, 19 ms)
        ↳1849 RelADPP
        ↳1850 RelADPDepGraphProof (⇔, 0 ms)
        ↳1851 TRUE
    ↳1852 RelADPP
    ↳1853 RelADPP
    ↳1854 RelADPP
        ↳1855 RelADPReductionPairProof (⇔, 26 ms)
        ↳1856 RelADPP
        ↳1857 RelADPDepGraphProof (⇔, 0 ms)
        ↳1858 TRUE
    ↳1859 RelADPP
    ↳1860 RelADPP
    ↳1861 RelADPP
    ↳1862 RelADPP
        ↳1863 RelADPReductionPairProof (⇔, 21 ms)
        ↳1864 RelADPP
        ↳1865 RelADPDepGraphProof (⇔, 0 ms)
        ↳1866 RelADPP
        ↳1867 RelADPReductionPairProof (⇔, 0 ms)
        ↳1868 RelADPP
        ↳1869 RelADPReductionPairProof (⇔, 53 ms)
        ↳1870 RelADPP
        ↳1871 RelADPReductionPairProof (⇔, 0 ms)
        ↳1872 RelADPP
        ↳1873 RelADPReductionPairProof (⇔, 35 ms)
        ↳1874 RelADPP
    ↳1875 RelADPP
    ↳1876 RelADPP
    ↳1877 RelADPP
    ↳1878 RelADPP
        ↳1879 RelADPReductionPairProof (⇔, 26 ms)
        ↳1880 RelADPP
        ↳1881 RelADPReductionPairProof (⇔, 29 ms)
        ↳1882 RelADPP
        ↳1883 RelADPDepGraphProof (⇔, 0 ms)
        ↳1884 TRUE
    ↳1885 RelADPP
        ↳1886 RelADPReductionPairProof (⇔, 176 ms)
        ↳1887 RelADPP
        ↳1888 RelADPDepGraphProof (⇔, 0 ms)
        ↳1889 TRUE
    ↳1890 RelADPP
    ↳1891 RelADPP
    ↳1892 RelADPP
        ↳1893 RelADPReductionPairProof (⇔, 0 ms)
        ↳1894 RelADPP
        ↳1895 RelADPDepGraphProof (⇔, 0 ms)
        ↳1896 RelADPP
        ↳1897 RelADPReductionPairProof (⇔, 12 ms)
        ↳1898 RelADPP
        ↳1899 RelADPReductionPairProof (⇔, 44 ms)
        ↳1900 RelADPP
        ↳1901 RelADPReductionPairProof (⇔, 14 ms)
        ↳1902 RelADPP
        ↳1903 RelADPReductionPairProof (⇔, 34 ms)
        ↳1904 RelADPP
        ↳1905 RelADPReductionPairProof (⇔, 44 ms)
        ↳1906 RelADPP
        ↳1907 RelADPDepGraphProof (⇔, 0 ms)
        ↳1908 TRUE
    ↳1909 RelADPP
    ↳1910 RelADPP
    ↳1911 RelADPP
        ↳1912 RelADPReductionPairProof (⇔, 4 ms)
        ↳1913 RelADPP
        ↳1914 RelADPDepGraphProof (⇔, 0 ms)
        ↳1915 TRUE
    ↳1916 RelADPP
        ↳1917 RelADPReductionPairProof (⇔, 33 ms)
        ↳1918 RelADPP
        ↳1919 RelADPDepGraphProof (⇔, 0 ms)
        ↳1920 TRUE
    ↳1921 RelADPP
    ↳1922 RelADPP
    ↳1923 RelADPP
        ↳1924 RelADPReductionPairProof (⇔, 25 ms)
        ↳1925 RelADPP
        ↳1926 RelADPDepGraphProof (⇔, 0 ms)
        ↳1927 TRUE
    ↳1928 RelADPP
    ↳1929 RelADPP
    ↳1930 RelADPP
    ↳1931 RelADPP
    ↳1932 RelADPP
    ↳1933 RelADPP
    ↳1934 RelADPP
        ↳1935 RelADPReductionPairProof (⇔, 30 ms)
        ↳1936 RelADPP
        ↳1937 RelADPDepGraphProof (⇔, 0 ms)
        ↳1938 RelADPP
        ↳1939 RelADPReductionPairProof (⇔, 17 ms)
        ↳1940 RelADPP
        ↳1941 RelADPReductionPairProof (⇔, 16 ms)
        ↳1942 RelADPP
        ↳1943 RelADPReductionPairProof (⇔, 65 ms)
        ↳1944 RelADPP
        ↳1945 RelADPReductionPairProof (⇔, 16 ms)
        ↳1946 RelADPP
        ↳1947 RelADPDepGraphProof (⇔, 0 ms)
        ↳1948 TRUE
    ↳1949 RelADPP
    ↳1950 RelADPP
    ↳1951 RelADPP
    ↳1952 RelADPP
    ↳1953 RelADPP
    ↳1954 RelADPP
    ↳1955 RelADPP
        ↳1956 RelADPReductionPairProof (⇔, 29 ms)
        ↳1957 RelADPP
        ↳1958 RelADPDepGraphProof (⇔, 0 ms)
        ↳1959 TRUE
    ↳1960 RelADPP
    ↳1961 RelADPP
    ↳1962 RelADPP
    ↳1963 RelADPP
    ↳1964 RelADPP

(0) Obligation:

Relative term rewrite system:
The relative TRS consists of the following R rules:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))
D(E, F(x, y)) → F(E, D(x, y))

The relative TRS consists of the following S rules:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1) RelTRStoRelADPProof (EQUIVALENT transformation)

We upgrade the RelTRS problem to an equivalent Relative ADP Problem [IJCAR24].

(2) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → TOP(check(D(x, y)))
top(ok(U(x, y))) → top(CHECK(D(x, y)))
top(ok(U(x, y))) → top(check(D1(x, y)))
D(x, B) → U1(x, B)
F(x, U(O(y), z)) → U1(x, F(y, z))
F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U1(x, F(y, z))
F(x, U(N(y), z)) → U(x, F1(y, z))
D(O(x), F(y, z)) → F1(x, D(y, z))
D(O(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F1(x, D(y, z))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(E, y)) → U1(x, F(E, y))
F(x, U(E, y)) → U(x, F1(E, y))
F(x, U(E, y)) → U(x, F(E1, y))
D(E, F(x, y)) → F1(E, D(x, y))
D(E, F(x, y)) → F(E1, D(x, y))
D(E, F(x, y)) → F(E, D1(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N1(E1)
F(ok(x), y) → ok(F1(x, y))
O(ok(x)) → ok(O1(x))
U(ok(x), y) → ok(U1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))
U(O(x), y) → U1(x, y)
check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U1(x, y)
D(O(x), y) → D1(x, y)
check(O(x)) → O1(CHECK(x))
N(ok(x)) → ok(N1(x))
D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(O(x)) → ok(O1(x))
check(F(x, y)) → F1(CHECK(x), y)
U(x, ok(y)) → ok(U1(x, y))
check(D(x, y)) → D1(x, CHECK(y))

(3) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
3 SCCs with nodes from P_abs,
555 Lassos,
Result: This relative DT problem is equivalent to 558 subproblems.

(4) Complex Obligation (AND)

(5) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(E, y)) → U(x, F1(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
check(N(x)) → N(check(x))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(6) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(E, y)) → U(x, F1(E, y))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 1 + x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x2   
POL(F1(x1, x2)) = 3·x2   
POL(N(x1)) = 1   
POL(N1(x1)) = 2 + 2·x1   
POL(O(x1)) = 0   
POL(O1(x1)) = 3   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 3 + x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(7) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(8) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(9) TRUE

(10) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(11) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(12) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(13) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + 3·x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(14) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(15) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = 1 + 3·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3·x1 + 3·x2   
POL(U1(x1, x2)) = 2 + 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(16) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(17) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(18) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(19) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))
D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 1 + x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = 2 + x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(20) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(21) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(22) TRUE

(23) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → TOP(check(D(x, y)))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(24) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(25) Obligation:

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

TOP(ok(U(x, y))) → TOP(check(D(x, y)))

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(26) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

U(O(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
D(O(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B) = 0   
POL(D(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(N(x1)) = 2·x1   
POL(O(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 2·x1   
POL(U(x1, x2)) = x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(27) Obligation:

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

TOP(ok(U(x, y))) → TOP(check(D(x, y)))

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(28) TransformationProof (EQUIVALENT transformation)

By narrowing [LPAR04] the rule TOP(ok(U(x, y))) → TOP(check(D(x, y))) at position [0] we obtained the following new rules [LPAR04]:

TOP(ok(U(x0, x1))) → TOP(D(x0, check(x1))) → TOP(ok(U(x0, x1))) → TOP(D(x0, check(x1)))
TOP(ok(U(x0, x1))) → TOP(D(check(x0), x1)) → TOP(ok(U(x0, x1))) → TOP(D(check(x0), x1))
TOP(ok(U(ok(x0), x1))) → TOP(check(ok(D(x0, x1)))) → TOP(ok(U(ok(x0), x1))) → TOP(check(ok(D(x0, x1))))
TOP(ok(U(x0, B))) → TOP(check(U(x0, B))) → TOP(ok(U(x0, B))) → TOP(check(U(x0, B)))
TOP(ok(U(E, F(x0, x1)))) → TOP(check(F(E, D(x0, x1)))) → TOP(ok(U(E, F(x0, x1)))) → TOP(check(F(E, D(x0, x1))))
TOP(ok(U(N(x0), x1))) → TOP(check(D(x0, x1))) → TOP(ok(U(N(x0), x1))) → TOP(check(D(x0, x1)))
TOP(ok(U(N(x0), F(x1, x2)))) → TOP(check(F(x0, D(x1, x2)))) → TOP(ok(U(N(x0), F(x1, x2)))) → TOP(check(F(x0, D(x1, x2))))
TOP(ok(U(x0, ok(x1)))) → TOP(check(ok(D(x0, x1)))) → TOP(ok(U(x0, ok(x1)))) → TOP(check(ok(D(x0, x1))))

(29) Obligation:

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

TOP(ok(U(x0, x1))) → TOP(D(x0, check(x1)))
TOP(ok(U(x0, x1))) → TOP(D(check(x0), x1))
TOP(ok(U(ok(x0), x1))) → TOP(check(ok(D(x0, x1))))
TOP(ok(U(x0, B))) → TOP(check(U(x0, B)))
TOP(ok(U(E, F(x0, x1)))) → TOP(check(F(E, D(x0, x1))))
TOP(ok(U(N(x0), x1))) → TOP(check(D(x0, x1)))
TOP(ok(U(N(x0), F(x1, x2)))) → TOP(check(F(x0, D(x1, x2))))
TOP(ok(U(x0, ok(x1)))) → TOP(check(ok(D(x0, x1))))

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(30) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.

(31) Obligation:

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

TOP(ok(U(x0, x1))) → TOP(D(x0, check(x1)))
TOP(ok(U(x0, x1))) → TOP(D(check(x0), x1))
TOP(ok(U(x0, B))) → TOP(check(U(x0, B)))
TOP(ok(U(E, F(x0, x1)))) → TOP(check(F(E, D(x0, x1))))
TOP(ok(U(N(x0), x1))) → TOP(check(D(x0, x1)))
TOP(ok(U(N(x0), F(x1, x2)))) → TOP(check(F(x0, D(x1, x2))))

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(32) NonTerminationLoopProof (COMPLETE transformation)

We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

s = TOP(D(check(O(x')), B)) evaluates to t =TOP(D(check(O(x')), B))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
  • Matcher: [ ]
  • Semiunifier: [ ]



Rewriting sequence

TOP(D(check(O(x')), B)) → TOP(D(ok(O(x')), B))
with rule check(O(x'')) → ok(O(x'')) at position [0,0] and matcher [x'' / x']

TOP(D(ok(O(x')), B)) → TOP(U(ok(O(x')), B))
with rule D(x'', B) → U(x'', B) at position [0] and matcher [x'' / ok(O(x'))]

TOP(U(ok(O(x')), B)) → TOP(ok(U(O(x'), B)))
with rule U(ok(x), y) → ok(U(x, y)) at position [0] and matcher [x / O(x'), y / B]

TOP(ok(U(O(x'), B))) → TOP(D(check(O(x')), B))
with rule TOP(ok(U(x0, x1))) → TOP(D(check(x0), x1))

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence


All these steps are and every following step will be a correct step w.r.t to Q.



(33) NO

(34) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(35) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1 + 3·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(36) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(37) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(38) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(39) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(40) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(41) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(42) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(43) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(44) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(45) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(46) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(47) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(48) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(49) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(50) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(51) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(52) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(53) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(U(x, y)) → U1(CHECK(x), y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 2 + 2·x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(54) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(55) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(56) TRUE

(57) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(58) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(59) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(60) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(61) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(62) TRUE

(63) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(64) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(65) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(66) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(67) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(68) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(69) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(70) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 2·x1 + x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(71) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(72) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
3 Lassos,
Result: This relative DT problem is equivalent to 3 subproblems.

(73) Complex Obligation (AND)

(74) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(75) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + x2   
POL(D1(x1, x2)) = 1   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 2·x12   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3 + 2·x1   
POL(ok(x1)) = 3 + x1   
POL(top(x1)) = 0   

(76) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(77) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + 3·x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(78) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(79) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(80) TRUE

(81) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(82) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + x2   
POL(D1(x1, x2)) = 1   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 2·x12   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3 + 2·x1   
POL(ok(x1)) = 3 + x1   
POL(top(x1)) = 0   

(83) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(84) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + 3·x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(85) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(86) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(87) TRUE

(88) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(89) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + x2   
POL(D1(x1, x2)) = 1   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 2·x12   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3 + 2·x1   
POL(ok(x1)) = 3 + x1   
POL(top(x1)) = 0   

(90) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(91) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + 3·x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(92) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(93) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(94) TRUE

(95) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(96) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(97) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 3   
POL(E1) = 1   
POL(F(x1, x2)) = 1 + x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 3   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(98) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(99) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(100) TRUE

(101) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(102) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + x2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(103) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(104) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(105) TRUE

(106) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(107) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2·x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(108) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(109) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3   
POL(D1(x1, x2)) = 1 + x1·x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2   
POL(N1(x1)) = 0   
POL(O(x1)) = 0   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = 3   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(110) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(111) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2·x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1 + x1·x2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(112) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(113) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(114) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(115) RelADPCleverAfsProof (SOUND transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

Furthermore, We use an argument filter [LPAR04].
Filtering:O_1 = N_1 = top_1 = E = check_1 = B = U_2 = F_2 = ok_1 = F^1_2 = 0 D_2 =
Found this filtering by looking at the following order that orders at least one DP strictly:Polynomial interpretation [POLO]:


POL(B) = 0   
POL(D(x1, x2)) = 2 + x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 2 + x1 + 2·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = 2 + x1   
POL(O(x1)) = 2 + x1   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(check(x1)) = 1 + x1   
POL(ok(x1)) = 2·x1   
POL(top(x1)) = 2·x1   

(116) Obligation:

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

F1(U0(N0(y), z)) → F1(z)

The TRS R consists of the following rules:

F0(ok0(x), y) → ok0(F0(x, y))
top0(ok0(U0(x, y))) → top0(check0(D0(x, y)))
O0(ok0(x)) → ok0(O0(x))
F0(x, U0(N0(y), z)) → U0(x, F0(y, z))
U0(ok0(x), y) → ok0(U0(x, y))
check0(U0(x, y)) → U0(check0(x), y)
D0(ok0(x), y) → ok0(D0(x, y))
U0(O0(x), y) → U0(x, y)
U0(N0(x), y) → U0(x, y)
F0(x, U0(O0(y), z)) → U0(x, F0(y, z))
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F0(x, y)) → F0(check0(x), y)
check0(D0(x, y)) → D0(x, check0(y))
F0(x, ok0(y)) → ok0(F0(x, y))
E0 → N0(E0)
D0(x, B0) → U0(x, B0)
D0(E0, F0(x, y)) → F0(E0, D0(x, y))
check0(N0(x)) → N0(check0(x))
check0(D0(x, y)) → D0(check0(x), y)
check0(F0(x, y)) → F0(x, check0(y))
check0(U0(x, y)) → U0(x, check0(y))
D0(O0(x), y) → D0(x, y)
check0(O0(x)) → O0(check0(x))
D0(N0(x), y) → D0(x, y)
D0(N0(x), F0(y, z)) → F0(x, D0(y, z))
D0(x, ok0(y)) → ok0(D0(x, y))
D0(O0(x), F0(y, z)) → F0(x, D0(y, z))
U0(x, ok0(y)) → ok0(U0(x, y))
F0(x, U0(E0, y)) → U0(x, F0(E0, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(117) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

U0(O0(x), y) → U0(x, y)
F0(x, U0(O0(y), z)) → U0(x, F0(y, z))
D0(O0(x), y) → D0(x, y)
D0(O0(x), F0(y, z)) → F0(x, D0(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B0) = 1   
POL(D0(x1, x2)) = x1 + x2   
POL(E0) = 2   
POL(F0(x1, x2)) = 1 + x1 + x2   
POL(F1(x1)) = 2·x1   
POL(N0(x1)) = x1   
POL(O0(x1)) = 2 + x1   
POL(U0(x1, x2)) = x1 + x2   
POL(check0(x1)) = 2 + x1   
POL(ok0(x1)) = 2 + x1   
POL(top0(x1)) = x1   

(118) Obligation:

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

F1(U0(N0(y), z)) → F1(z)

The TRS R consists of the following rules:

F0(ok0(x), y) → ok0(F0(x, y))
top0(ok0(U0(x, y))) → top0(check0(D0(x, y)))
O0(ok0(x)) → ok0(O0(x))
F0(x, U0(N0(y), z)) → U0(x, F0(y, z))
U0(ok0(x), y) → ok0(U0(x, y))
check0(U0(x, y)) → U0(check0(x), y)
D0(ok0(x), y) → ok0(D0(x, y))
U0(N0(x), y) → U0(x, y)
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F0(x, y)) → F0(check0(x), y)
check0(D0(x, y)) → D0(x, check0(y))
F0(x, ok0(y)) → ok0(F0(x, y))
E0 → N0(E0)
D0(x, B0) → U0(x, B0)
D0(E0, F0(x, y)) → F0(E0, D0(x, y))
check0(N0(x)) → N0(check0(x))
check0(D0(x, y)) → D0(check0(x), y)
check0(F0(x, y)) → F0(x, check0(y))
check0(U0(x, y)) → U0(x, check0(y))
check0(O0(x)) → O0(check0(x))
D0(N0(x), y) → D0(x, y)
D0(N0(x), F0(y, z)) → F0(x, D0(y, z))
D0(x, ok0(y)) → ok0(D0(x, y))
U0(x, ok0(y)) → ok0(U0(x, y))
F0(x, U0(E0, y)) → U0(x, F0(E0, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(119) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

F1(U0(N0(y), z)) → F1(z)


Used ordering: Polynomial interpretation [POLO]:

POL(B0) = 0   
POL(D0(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(E0) = 2   
POL(F0(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(F1(x1)) = x1   
POL(N0(x1)) = x1   
POL(O0(x1)) = 2 + 2·x1   
POL(U0(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(check0(x1)) = x1   
POL(ok0(x1)) = x1   
POL(top0(x1)) = x1   

(120) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F0(ok0(x), y) → ok0(F0(x, y))
top0(ok0(U0(x, y))) → top0(check0(D0(x, y)))
O0(ok0(x)) → ok0(O0(x))
F0(x, U0(N0(y), z)) → U0(x, F0(y, z))
U0(ok0(x), y) → ok0(U0(x, y))
check0(U0(x, y)) → U0(check0(x), y)
D0(ok0(x), y) → ok0(D0(x, y))
U0(N0(x), y) → U0(x, y)
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F0(x, y)) → F0(check0(x), y)
check0(D0(x, y)) → D0(x, check0(y))
F0(x, ok0(y)) → ok0(F0(x, y))
E0 → N0(E0)
D0(x, B0) → U0(x, B0)
D0(E0, F0(x, y)) → F0(E0, D0(x, y))
check0(N0(x)) → N0(check0(x))
check0(D0(x, y)) → D0(check0(x), y)
check0(F0(x, y)) → F0(x, check0(y))
check0(U0(x, y)) → U0(x, check0(y))
check0(O0(x)) → O0(check0(x))
D0(N0(x), y) → D0(x, y)
D0(N0(x), F0(y, z)) → F0(x, D0(y, z))
D0(x, ok0(y)) → ok0(D0(x, y))
U0(x, ok0(y)) → ok0(U0(x, y))
F0(x, U0(E0, y)) → U0(x, F0(E0, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(121) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(122) YES

(123) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(124) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(125) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(126) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(127) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(128) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(x, B) → U(x, B)

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(129) Obligation:

Relative ADP Problem with
absolute ADPs:

D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(130) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(131) TRUE

(132) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(133) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(134) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(135) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(136) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 3·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(137) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(138) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(139) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(140) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(141) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(142) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(143) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(144) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(145) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(146) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(147) TRUE

(148) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(149) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(150) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(151) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(152) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(153) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(154) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 3·x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 3·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 2·x1   

(155) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(156) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(157) TRUE

(158) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(159) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(160) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F1(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(161) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F1(E, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(162) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(163) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(164) TRUE

(165) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(166) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(167) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(168) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(169) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(170) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(171) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 2 + 2·x1   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(172) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(173) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 2 + x1 + x12   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(174) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(175) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(176) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(177) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(178) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(179) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(180) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(181) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + x1 + x2   
POL(D1(x1, x2)) = x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 3 + x1   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(182) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(183) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(184) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(185) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(186) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(187) TRUE

(188) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(189) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(190) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(191) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(192) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(193) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(194) TRUE

(195) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(196) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(197) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(198) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(199) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(200) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(201) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(202) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(203) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(204) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(205) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(206) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(207) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(208) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(209) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(210) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(211) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(212) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 3 + x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(213) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(214) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(O(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 2·x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(215) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(216) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 2·x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = 2 + x1·x2 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(217) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(218) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(219) Obligation:

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

D1(N(x), F(y, z)) → D1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(220) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

U(O(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
D(O(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B) = 2   
POL(D(x1, x2)) = 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 2 + 2·x1   
POL(U(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(221) Obligation:

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

D1(N(x), F(y, z)) → D1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(222) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

D1(N(x), F(y, z)) → D1(y, z)


Used ordering: Polynomial interpretation [POLO]:

POL(B) = 0   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 2·x1   
POL(U(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(223) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(224) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(225) YES

(226) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(227) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 1 + 3·x1 + x2   
POL(D1(x1, x2)) = 1 + 2·x1   
POL(E) = 1   
POL(E1) = 0   
POL(F(x1, x2)) = 3 + 3·x1 + x2   
POL(F1(x1, x2)) = 3 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 3·x1 + x2   
POL(U1(x1, x2)) = 1   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(228) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(229) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(230) TRUE

(231) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(232) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(233) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(234) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(235) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + 3·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x1 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(236) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(237) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(238) TRUE

(239) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(240) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(241) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(242) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U1(x, F(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 1 + 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(243) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(244) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(245) TRUE

(246) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(247) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(248) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 2   
POL(top(x1)) = 0   

(249) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(250) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(251) TRUE

(252) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(253) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + x2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(254) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(255) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(256) TRUE

(257) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(258) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(259) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(260) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(261) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(262) TRUE

(263) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(264) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(265) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(266) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(267) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(268) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(269) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(270) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(271) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(272) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(273) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(274) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(275) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(276) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(277) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(278) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(279) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(280) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(281) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(282) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(283) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(284) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(285) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(286) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U1(x, F(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(287) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(288) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(289) TRUE

(290) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(291) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(292) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(293) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(294) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(295) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(296) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(297) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(298) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(299) TRUE

(300) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(301) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x12   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(302) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(303) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = x1 + x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 2 + x1 + x12   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(304) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(305) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(306) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(307) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(308) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(309) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(310) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(311) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(312) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(313) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(314) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(315) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(316) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + 3·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 2 + x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(317) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(318) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(319) TRUE

(320) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(321) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(322) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(323) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U1(x, F(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 3 + 2·x1 + x2   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(324) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(325) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(326) TRUE

(327) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(328) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(329) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + 3·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(330) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(331) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(332) TRUE

(333) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(334) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(335) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(336) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(337) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(338) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(339) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3 + 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(340) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(341) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(342) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(343) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(344) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(345) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3 + 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(346) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(347) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + 3·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(348) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(349) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 2·x1 + x2   
POL(D1(x1, x2)) = 2·x1 + 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 1 + x1 + x12   
POL(U(x1, x2)) = 2 + 2·x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 2   
POL(top(x1)) = 0   

(350) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(351) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2 + 2·x1·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(352) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(353) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 3 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(354) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(355) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:

Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + x2   
POL(D1(x1, x2)) = 2 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = 2 + x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(356) Obligation:

Relative ADP Problem with
No absolute ADPs, and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(357) DAbsisEmptyProof (EQUIVALENT transformation)

The RDT Problem has an empty P_abs. Hence, no infinite chain exists.

(358) YES

(359) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(360) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(361) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(362) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(363) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(364) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(365) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(366) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(367) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 2   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x12   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2 + x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(368) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(369) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(370) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(371) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(372) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(373) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + 3·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(374) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(375) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(376) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
F(ok(x), y) → ok(F1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 3   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 2   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x12   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(377) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(378) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 2   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 2 + x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(379) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(380) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(381) TRUE

(382) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(383) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(384) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x12   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(385) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(386) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2·x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 3·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(387) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(388) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(389) TRUE

(390) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(391) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(392) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + x2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(393) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(394) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(395) TRUE

(396) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(397) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(398) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
F(ok(x), y) → ok(F1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x12   
POL(U(x1, x2)) = 2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(399) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(400) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 3 + 2·x1   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 1   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 3 + x1   
POL(top(x1)) = 0   

(401) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(402) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(403) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(404) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + 2·x1   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(405) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(406) RelADPCleverAfsProof (SOUND transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

Furthermore, We use an argument filter [LPAR04].
Filtering:O_1 = N_1 = E = top_1 = check_1 = B = U_2 = 0 F_2 = 0 F^1_2 = 0 ok_1 = D_2 = 0, 1
Found this filtering by looking at the following order that orders at least one DP strictly:Combined order from the following AFS and order.
F1(x1, x2)  =  F1(x2)
U(x1, x2)  =  U(x2)
N(x1)  =  x1
F(x1, x2)  =  x2
O(x1)  =  x1
D(x1, x2)  =  D
B  =  B
E  =  E

Recursive path order with status [RPO].
Quasi-Precedence:

[D, E] > [U1, B]

Status:
F^11: [1]
U1: [1]
D: []
B: multiset
E: multiset

(407) Obligation:

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

F1(U(z)) → F1(z)

The TRS R consists of the following rules:

F(y) → ok0(F(y))
top0(ok0(U(y))) → top0(check0(D))
O0(ok0(x)) → ok0(O0(x))
F(U(z)) → U(F(z))
U(y) → ok0(U(y))
check0(U(y)) → U(y)
D → ok0(D)
U(y) → U(y)
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F(y)) → F(y)
check0(D) → D
F(ok0(y)) → ok0(F(y))
E0 → N0(E0)
D → U(B0)
D → F(D)
check0(N0(x)) → N0(check0(x))
check0(F(y)) → F(check0(y))
check0(U(y)) → U(check0(y))
D → D
check0(O0(x)) → O0(check0(x))
U(ok0(y)) → ok0(U(y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(408) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

check0(O0(x)) → ok0(O0(x))
check0(O0(x)) → O0(check0(x))

Used ordering: Polynomial interpretation [POLO]:

POL(B0) = 0   
POL(D) = 0   
POL(E0) = 1   
POL(F(x1)) = 2·x1   
POL(F1(x1)) = x1   
POL(N0(x1)) = x1   
POL(O0(x1)) = 1 + 2·x1   
POL(U(x1)) = x1   
POL(check0(x1)) = 2·x1   
POL(ok0(x1)) = x1   
POL(top0(x1)) = x1   

(409) Obligation:

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

F1(U(z)) → F1(z)

The TRS R consists of the following rules:

F(y) → ok0(F(y))
top0(ok0(U(y))) → top0(check0(D))
O0(ok0(x)) → ok0(O0(x))
F(U(z)) → U(F(z))
U(y) → ok0(U(y))
check0(U(y)) → U(y)
D → ok0(D)
U(y) → U(y)
N0(ok0(x)) → ok0(N0(x))
check0(F(y)) → F(y)
check0(D) → D
F(ok0(y)) → ok0(F(y))
E0 → N0(E0)
D → U(B0)
D → F(D)
check0(N0(x)) → N0(check0(x))
check0(F(y)) → F(check0(y))
check0(U(y)) → U(check0(y))
D → D
U(ok0(y)) → ok0(U(y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(410) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

F1(U(z)) → F1(z)


Used ordering: Polynomial interpretation [POLO]:

POL(B0) = 0   
POL(D) = 1   
POL(E0) = 2   
POL(F(x1)) = x1   
POL(F1(x1)) = 2·x1   
POL(N0(x1)) = x1   
POL(O0(x1)) = 1 + 2·x1   
POL(U(x1)) = 1 + x1   
POL(check0(x1)) = x1   
POL(ok0(x1)) = x1   
POL(top0(x1)) = 2·x1   

(411) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(y) → ok0(F(y))
top0(ok0(U(y))) → top0(check0(D))
O0(ok0(x)) → ok0(O0(x))
F(U(z)) → U(F(z))
U(y) → ok0(U(y))
check0(U(y)) → U(y)
D → ok0(D)
U(y) → U(y)
N0(ok0(x)) → ok0(N0(x))
check0(F(y)) → F(y)
check0(D) → D
F(ok0(y)) → ok0(F(y))
E0 → N0(E0)
D → U(B0)
D → F(D)
check0(N0(x)) → N0(check0(x))
check0(F(y)) → F(check0(y))
check0(U(y)) → U(check0(y))
D → D
U(ok0(y)) → ok0(U(y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(412) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(413) YES

(414) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(415) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(416) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 3·x1   

(417) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(418) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(419) TRUE

(420) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(421) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(422) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(423) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(424) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(425) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(426) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(427) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(428) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(429) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(430) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(431) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(432) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(433) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(434) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(435) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(436) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(437) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(438) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(439) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(440) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = x1 + x1·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(441) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(442) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + x2   
POL(F1(x1, x2)) = 2 + 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(443) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(444) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = 2 + x1 + x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(445) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(446) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(447) TRUE

(448) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(449) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(450) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(451) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(452) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(453) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(454) TRUE

(455) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(456) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(457) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(458) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x1   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(459) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(460) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(461) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(462) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(x, B) → U(x, B)

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + 3·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 3·x1 + x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(463) Obligation:

Relative ADP Problem with
absolute ADPs:

D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(464) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(465) TRUE

(466) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(467) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(468) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(469) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(470) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(471) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(472) TRUE

(473) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(474) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(475) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(476) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(477) TRUE

(478) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(479) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(480) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(481) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(482) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(483) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 3·x1 + x1·x2   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x12   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(484) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(485) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(486) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(487) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(488) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(489) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(490) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(491) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 3·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = 3   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(492) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(493) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(494) TRUE

(495) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(496) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(497) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(498) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(499) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(500) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = x1   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(501) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(502) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(503) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(504) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 3·x1 + x1·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(505) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(506) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(507) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(508) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:

Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + x1·x2   
POL(N(x1)) = 1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 1 + x1 + x12   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(509) Obligation:

Relative ADP Problem with
No absolute ADPs, and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(510) DAbsisEmptyProof (EQUIVALENT transformation)

The RDT Problem has an empty P_abs. Hence, no infinite chain exists.

(511) YES

(512) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F1(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(513) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F1(E, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(514) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(515) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(516) TRUE

(517) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(518) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(519) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(520) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(521) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(522) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(523) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(524) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(525) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x1 + x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(526) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(527) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(528) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(529) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 1 + x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(530) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(531) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = x12   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 2 + 2·x1 + x2   
POL(U1(x1, x2)) = x1·x2 + 2·x2   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = 2   
POL(top(x1)) = 0   

(532) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(533) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1 + x1 + x12   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(534) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(535) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(536) Obligation:

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

D1(N(x), F(y, z)) → D1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(537) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

U(O(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
D(O(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B) = 2   
POL(D(x1, x2)) = 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 2 + 2·x1   
POL(U(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(538) Obligation:

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

D1(N(x), F(y, z)) → D1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(539) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

D1(N(x), F(y, z)) → D1(y, z)


Used ordering: Polynomial interpretation [POLO]:

POL(B) = 0   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 2·x1   
POL(U(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(540) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(541) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(542) YES

(543) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(544) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(545) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(546) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(547) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(548) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(549) TRUE

(550) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(551) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 3·x1 + x2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2 + 3·x1 + x2   
POL(F1(x1, x2)) = 1 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + x2   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(552) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(553) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(554) TRUE

(555) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(556) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(557) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(558) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(559) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(560) TRUE

(561) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(562) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(563) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(564) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(565) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(566) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(567) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(568) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(569) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(570) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(571) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(572) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(573) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(574) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(575) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(576) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(577) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = x1 + x1·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(578) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(579) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + x2   
POL(F1(x1, x2)) = 2 + 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(580) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(581) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = 2 + x1 + x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(582) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(583) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(584) TRUE

(585) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(586) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(587) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(588) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(589) TRUE

(590) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(591) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(592) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(593) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(594) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(595) TRUE

(596) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(597) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(598) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1 + x1   
POL(U(x1, x2)) = 3 + x1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(599) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(600) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 2 + x1 + x12   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(601) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(602) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(603) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(604) RelADPCleverAfsProof (SOUND transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

Furthermore, We use an argument filter [LPAR04].
Filtering:O_1 = N_1 = E = top_1 = check_1 = B = D^1_2 = 0 U_2 = 0 F_2 = 0 ok_1 = D_2 = 0
Found this filtering by looking at the following order that orders at least one DP strictly:Combined order from the following AFS and order.
D1(x1, x2)  =  D1(x2)
N(x1)  =  N(x1)
F(x1, x2)  =  F(x2)
U(x1, x2)  =  x2
O(x1)  =  O(x1)
D(x1, x2)  =  D(x2)
B  =  B
E  =  E

Recursive path order with status [RPO].
Quasi-Precedence:

N1 > [F1, O1, D1] > B
E > [F1, O1, D1] > B

Status:
D^11: [1]
N1: multiset
F1: [1]
O1: multiset
D1: [1]
B: multiset
E: multiset

(605) Obligation:

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

D1(F(z)) → D1(z)

The TRS R consists of the following rules:

F(y) → ok0(F(y))
top0(ok0(U(y))) → top0(check0(D(y)))
O0(ok0(x)) → ok0(O0(x))
F(U(z)) → U(F(z))
U(y) → ok0(U(y))
check0(U(y)) → U(y)
D(y) → ok0(D(y))
U(y) → U(y)
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F(y)) → F(y)
check0(D(y)) → D(check0(y))
F(ok0(y)) → ok0(F(y))
E0 → N0(E0)
D(B0) → U(B0)
D(F(y)) → F(D(y))
check0(N0(x)) → N0(check0(x))
check0(D(y)) → D(y)
check0(F(y)) → F(check0(y))
check0(U(y)) → U(check0(y))
D(y) → D(y)
check0(O0(x)) → O0(check0(x))
D(ok0(y)) → ok0(D(y))
U(ok0(y)) → ok0(U(y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(606) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

D1(F(z)) → D1(z)


Used ordering: Polynomial interpretation [POLO]:

POL(B0) = 0   
POL(D(x1)) = x1   
POL(D1(x1)) = x1   
POL(E0) = 2   
POL(F(x1)) = 2 + 2·x1   
POL(N0(x1)) = x1   
POL(O0(x1)) = 2 + x1   
POL(U(x1)) = x1   
POL(check0(x1)) = x1   
POL(ok0(x1)) = x1   
POL(top0(x1)) = x1   

(607) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(y) → ok0(F(y))
top0(ok0(U(y))) → top0(check0(D(y)))
O0(ok0(x)) → ok0(O0(x))
F(U(z)) → U(F(z))
U(y) → ok0(U(y))
check0(U(y)) → U(y)
D(y) → ok0(D(y))
U(y) → U(y)
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F(y)) → F(y)
check0(D(y)) → D(check0(y))
F(ok0(y)) → ok0(F(y))
E0 → N0(E0)
D(B0) → U(B0)
D(F(y)) → F(D(y))
check0(N0(x)) → N0(check0(x))
check0(D(y)) → D(y)
check0(F(y)) → F(check0(y))
check0(U(y)) → U(check0(y))
D(y) → D(y)
check0(O0(x)) → O0(check0(x))
D(ok0(y)) → ok0(D(y))
U(ok0(y)) → ok0(U(y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(608) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(609) YES

(610) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(611) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + 3·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 2 + x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(612) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(613) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(614) TRUE

(615) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(616) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(617) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(618) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
3 Lassos,
Result: This relative DT problem is equivalent to 4 subproblems.

(619) Complex Obligation (AND)

(620) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(621) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(622) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(623) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(624) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(625) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(626) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(627) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(628) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(629) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(630) TRUE

(631) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(632) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2·x1 + x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(633) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(634) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(635) TRUE

(636) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(637) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2·x1 + x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(638) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(639) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(640) TRUE

(641) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(642) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2·x1 + x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(643) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(644) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(645) TRUE

(646) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(647) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(648) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(649) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(650) TRUE

(651) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(652) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(653) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(654) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(655) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(656) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(657) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(658) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(659) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(660) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(661) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(662) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(663) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(664) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 3 + x1   
POL(top(x1)) = 0   

(665) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(666) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(667) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(668) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(669) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(670) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:

Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 1 + 3·x2   
POL(D1(x1, x2)) = 2 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(671) Obligation:

Relative ADP Problem with
No absolute ADPs, and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(672) DAbsisEmptyProof (EQUIVALENT transformation)

The RDT Problem has an empty P_abs. Hence, no infinite chain exists.

(673) YES

(674) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(675) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(676) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(U(x, y)) → U1(CHECK(x), y)
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2 + x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(677) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(678) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(679) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(680) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + 2·x1   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + x1·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(681) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(682) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2·x1 + 2·x1·x2 + x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(683) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(684) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(685) Obligation:

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

F1(x, U(N(y), z)) → F1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(686) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

U(O(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
D(O(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B) = 0   
POL(D(x1, x2)) = x1 + 2·x2   
POL(E) = 1   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 2 + 2·x1   
POL(U(x1, x2)) = x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(687) Obligation:

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

F1(x, U(N(y), z)) → F1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(688) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

F1(x, U(N(y), z)) → F1(y, z)


Used ordering: Polynomial interpretation [POLO]:

POL(B) = 1   
POL(D(x1, x2)) = 2 + x1 + x2   
POL(E) = 2   
POL(F(x1, x2)) = 1 + x1 + x2   
POL(F1(x1, x2)) = x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 1 + x1   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(check(x1)) = 2 + x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = x1   

(689) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(690) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(691) YES

(692) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(693) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(694) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(695) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(696) TRUE

(697) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(698) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x12   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(699) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(700) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(701) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(702) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(703) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(704) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(705) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(706) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(707) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(708) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(709) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(710) TRUE

(711) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(712) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(713) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(714) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(715) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x2   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(716) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(717) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(718) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(719) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(720) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(721) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 3 + x1   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(722) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(723) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 2 + 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(724) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(725) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3 + 2·x1   
POL(U(x1, x2)) = 2·x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(726) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(727) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:

Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + x2   
POL(D1(x1, x2)) = 2 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = 2 + x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(728) Obligation:

Relative ADP Problem with
No absolute ADPs, and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(729) DAbsisEmptyProof (EQUIVALENT transformation)

The RDT Problem has an empty P_abs. Hence, no infinite chain exists.

(730) YES

(731) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(732) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(733) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(734) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(735) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(736) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

U(O(x), y) → U(x, y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
F(ok(x), y) → ok(F1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 0   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3 + x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(737) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(738) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
F(ok(x), y) → ok(F1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 0   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3 + 2·x1   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 1 + 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(739) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(740) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(741) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(742) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(743) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(744) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(745) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(746) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + 3·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(747) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(748) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(749) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(750) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1 + 3·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(751) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(752) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(753) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(754) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(755) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(756) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(757) TRUE

(758) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(759) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(760) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(761) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(762) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(763) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(764) TRUE

(765) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(766) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(767) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(768) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(769) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(770) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(771) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(772) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(773) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(774) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(775) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(776) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2   
POL(N(x1)) = 0   
POL(N1(x1)) = 2   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3 + 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(777) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(778) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x12   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(779) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(780) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = 2 + x1 + x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = x12   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = x1 + 3·x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(781) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(782) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:

Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + x2   
POL(D1(x1, x2)) = 2 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = 2 + x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(783) Obligation:

Relative ADP Problem with
No absolute ADPs, and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(784) DAbsisEmptyProof (EQUIVALENT transformation)

The RDT Problem has an empty P_abs. Hence, no infinite chain exists.

(785) YES

(786) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(787) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(788) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(789) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(790) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(791) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(792) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(793) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(794) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(795) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(796) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = 1 + x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(797) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(798) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x2   
POL(F1(x1, x2)) = x1 + x1·x2   
POL(N(x1)) = 2   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(799) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(800) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(801) TRUE

(802) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(803) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(804) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(805) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(806) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(807) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(808) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
3 Lassos,
Result: This relative DT problem is equivalent to 4 subproblems.

(809) Complex Obligation (AND)

(810) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(811) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(812) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(813) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(814) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(815) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(816) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(817) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 1   
POL(N1(x1)) = x1 + x12   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(818) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(819) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(820) TRUE

(821) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(822) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2·x1 + x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(823) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(824) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(825) TRUE

(826) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(827) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2·x1 + x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(828) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(829) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(830) TRUE

(831) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(832) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2·x1 + x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(833) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(834) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(835) TRUE

(836) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(837) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(838) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(839) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(840) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(841) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(842) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(U(x, y)) → U1(CHECK(x), y)
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2 + x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(843) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(844) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(845) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(846) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + 2·x1   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + x1·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(847) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(848) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2·x1 + 2·x1·x2 + x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(849) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(850) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(851) Obligation:

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

F1(x, U(N(y), z)) → F1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(852) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

U(O(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
D(O(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B) = 0   
POL(D(x1, x2)) = x1 + 2·x2   
POL(E) = 1   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 2 + 2·x1   
POL(U(x1, x2)) = x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(853) Obligation:

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

F1(x, U(N(y), z)) → F1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(854) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

F1(x, U(N(y), z)) → F1(y, z)


Used ordering: Polynomial interpretation [POLO]:

POL(B) = 1   
POL(D(x1, x2)) = 2 + x1 + x2   
POL(E) = 2   
POL(F(x1, x2)) = 1 + x1 + x2   
POL(F1(x1, x2)) = x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 1 + x1   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(check(x1)) = 2 + x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = x1   

(855) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(856) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(857) YES

(858) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(859) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(860) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U1(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 3·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(861) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(862) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(863) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(864) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(865) TRUE

(866) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(867) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(868) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(869) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(870) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(871) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(872) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(873) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(874) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(875) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(876) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(877) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(878) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(879) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(880) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(881) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = 1 + x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(882) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(883) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x2   
POL(F1(x1, x2)) = x1 + x1·x2   
POL(N(x1)) = 2   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(884) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(885) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(886) TRUE

(887) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(888) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 2·x1   

(889) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(890) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(891) TRUE

(892) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(893) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2   
POL(N1(x1)) = 0   
POL(O(x1)) = 2   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(894) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(895) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + x1 + 2·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + x2   
POL(F1(x1, x2)) = 2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x1   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(896) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(897) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(898) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(899) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(900) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(901) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(902) TRUE

(903) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(904) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(905) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(906) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(907) TRUE

(908) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(909) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(910) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(911) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(912) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(913) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U1(x, B)

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x1 + 2·x2   
POL(F1(x1, x2)) = 2   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(914) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U1(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(915) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(916) TRUE

(917) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(918) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(919) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(920) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 0   
POL(F(x1, x2)) = 3   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(921) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(922) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(U(x, y)) → U1(CHECK(x), y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 0   
POL(F(x1, x2)) = 3 + 2·x1 + x2   
POL(F1(x1, x2)) = 1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(923) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(O(x), y) → D(x, y)
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(924) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(925) TRUE

(926) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(927) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(928) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(929) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(930) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(931) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(932) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(933) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(934) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = x1 + x1·x2   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(935) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(936) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 1   
POL(N1(x1)) = x1   
POL(O(x1)) = 0   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(937) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(938) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(939) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(940) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(941) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(942) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(943) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 3 + 2·x1 + x2   
POL(D1(x1, x2)) = 3   
POL(E) = 0   
POL(E1) = 0   
POL(F(x1, x2)) = 2 + 2·x1 + x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2·x1   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 3   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(944) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(945) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(946) TRUE

(947) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(948) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(949) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(950) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(951) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F1(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(952) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F1(E, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(953) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(954) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(955) TRUE

(956) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(957) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(958) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(959) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(960) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(961) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(962) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(963) TRUE

(964) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(965) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(966) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(967) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(968) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(969) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(970) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(971) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(972) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(973) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(974) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 3·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(975) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(976) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2 + x1 + x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1 + 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(977) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(978) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(979) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(980) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3·x2   
POL(D1(x1, x2)) = 1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(981) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(982) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = x1 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(983) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(984) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(985) TRUE

(986) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(987) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(988) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2·x1   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 3·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(989) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(990) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(991) TRUE

(992) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(993) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(994) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(995) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(996) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(997) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(998) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(999) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1000) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1001) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1002) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1003) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1004) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1005) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1006) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1007) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1008) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1009) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1010) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1011) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1012) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1013) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 3·x1   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1014) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1015) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1016) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1017) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 1 + x1   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(1018) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1019) RelADPCleverAfsProof (SOUND transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

Furthermore, We use an argument filter [LPAR04].
Filtering:O_1 = N_1 = E = top_1 = check_1 = B = D^1_2 = 0 U_2 = 0 F_2 = 0 ok_1 = D_2 = 0
Found this filtering by looking at the following order that orders at least one DP strictly:Combined order from the following AFS and order.
D1(x1, x2)  =  D1(x2)
E  =  E
F(x1, x2)  =  F(x2)
U(x1, x2)  =  U(x2)
N(x1)  =  x1
O(x1)  =  x1
D(x1, x2)  =  D(x2)
B  =  B

Recursive path order with status [RPO].
Quasi-Precedence:

D1 > [F1, U1] > E
D1 > B

Status:
D^11: [1]
E: multiset
F1: [1]
U1: [1]
D1: [1]
B: multiset

(1020) Obligation:

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

D1(F(y)) → D1(y)

The TRS R consists of the following rules:

F(y) → ok0(F(y))
top0(ok0(U(y))) → top0(check0(D(y)))
O0(ok0(x)) → ok0(O0(x))
F(U(z)) → U(F(z))
U(y) → ok0(U(y))
check0(U(y)) → U(y)
D(y) → ok0(D(y))
U(y) → U(y)
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F(y)) → F(y)
check0(D(y)) → D(check0(y))
F(ok0(y)) → ok0(F(y))
E0 → N0(E0)
D(B0) → U(B0)
D(F(y)) → F(D(y))
check0(N0(x)) → N0(check0(x))
check0(D(y)) → D(y)
check0(F(y)) → F(check0(y))
check0(U(y)) → U(check0(y))
D(y) → D(y)
check0(O0(x)) → O0(check0(x))
D(ok0(y)) → ok0(D(y))
U(ok0(y)) → ok0(U(y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1021) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

D1(F(y)) → D1(y)


Used ordering: Polynomial interpretation [POLO]:

POL(B0) = 0   
POL(D(x1)) = x1   
POL(D1(x1)) = x1   
POL(E0) = 2   
POL(F(x1)) = 2 + 2·x1   
POL(N0(x1)) = x1   
POL(O0(x1)) = 2 + x1   
POL(U(x1)) = x1   
POL(check0(x1)) = x1   
POL(ok0(x1)) = x1   
POL(top0(x1)) = x1   

(1022) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(y) → ok0(F(y))
top0(ok0(U(y))) → top0(check0(D(y)))
O0(ok0(x)) → ok0(O0(x))
F(U(z)) → U(F(z))
U(y) → ok0(U(y))
check0(U(y)) → U(y)
D(y) → ok0(D(y))
U(y) → U(y)
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F(y)) → F(y)
check0(D(y)) → D(check0(y))
F(ok0(y)) → ok0(F(y))
E0 → N0(E0)
D(B0) → U(B0)
D(F(y)) → F(D(y))
check0(N0(x)) → N0(check0(x))
check0(D(y)) → D(y)
check0(F(y)) → F(check0(y))
check0(U(y)) → U(check0(y))
D(y) → D(y)
check0(O0(x)) → O0(check0(x))
D(ok0(y)) → ok0(D(y))
U(ok0(y)) → ok0(U(y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1023) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(1024) YES

(1025) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1026) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1027) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1028) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1029) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1030) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1031) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1032) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1033) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1034) TRUE

(1035) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1036) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 3·x1   

(1037) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1038) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1039) TRUE

(1040) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F1(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1041) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F1(E, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1042) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1043) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1044) TRUE

(1045) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1046) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U1(x, F(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1047) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U1(x, F(E, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(1048) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1049) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1050) TRUE

(1051) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1052) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1053) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1054) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1055) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1056) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1057) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1058) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1059) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1060) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 3 + x1   
POL(top(x1)) = 0   

(1061) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1062) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1063) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1064) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(1065) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1066) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1067) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1068) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1069) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1070) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1071) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1072) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1073) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1074) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1075) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = x1 + x1·x2   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1076) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1077) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 1   
POL(N1(x1)) = x1   
POL(O(x1)) = 0   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1078) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1079) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1080) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1081) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 1 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1082) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1083) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + 3·x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1084) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1085) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1086) TRUE

(1087) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1088) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(1089) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1090) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(x, B) → U(x, B)

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 2 + x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1091) Obligation:

Relative ADP Problem with
absolute ADPs:

D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1092) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1093) TRUE

(1094) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1095) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1096) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1097) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1098) TRUE

(1099) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1100) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1101) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1102) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1103) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1104) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1105) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1106) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x1 + 2·x2   
POL(D1(x1, x2)) = x1   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3·x1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1107) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1108) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

Relative ADPs:

F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 3·x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 2 + x1·x2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1109) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

and relative ADPs:

O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
F(ok(x), y) → ok(F1(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1110) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1111) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(ok(x), y) → ok(F1(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1112) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1113) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(ok(x), y) → ok(F1(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1114) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = x1   
POL(D(x1, x2)) = 1 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + x1·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x12   
POL(O(x1)) = 1 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + x1 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1115) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

and relative ADPs:

O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(ok(x), y) → ok(F1(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1116) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1117) TRUE

(1118) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1119) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1120) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2   
POL(N1(x1)) = 0   
POL(O(x1)) = 2   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1121) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1122) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 3 + x1   
POL(TOP(x1)) = x1   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 3 + x1   
POL(top(x1)) = 0   

(1123) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1124) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1125) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1126) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1127) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1128) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3 + 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(1129) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1130) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(1131) Obligation:

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

D1(O(x), F(y, z)) → D1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1132) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

D1(O(x), F(y, z)) → D1(y, z)

Strictly oriented rules of the TRS R:

U(O(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
D(O(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 1 + 2·x1   
POL(U(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(1133) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1134) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(1135) YES

(1136) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1137) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1138) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1139) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1140) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1141) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1142) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1143) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x12   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2 + x1 + x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1144) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1145) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1146) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1147) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 3·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2·x1 + x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1148) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1149) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 1   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x12   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1150) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1151) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = x1 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1152) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1153) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1154) TRUE

(1155) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1156) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1157) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1158) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1159) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1160) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1161) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1162) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + x2   
POL(F1(x1, x2)) = x1·x2 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1163) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1164) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + x2   
POL(D1(x1, x2)) = x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 0   
POL(N1(x1)) = x12   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1165) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1166) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 1 + x1   
POL(D(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(1167) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1168) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1169) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1170) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 1 + x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1 + 2·x1 + x12   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(1171) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1172) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:

Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + x2   
POL(D1(x1, x2)) = 2 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = 1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 3   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 2 + x1 + x12   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 2 + x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1173) Obligation:

Relative ADP Problem with
No absolute ADPs, and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1174) DAbsisEmptyProof (EQUIVALENT transformation)

The RDT Problem has an empty P_abs. Hence, no infinite chain exists.

(1175) YES

(1176) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1177) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 2   
POL(top(x1)) = 0   

(1178) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1179) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 3·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1180) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1181) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1182) TRUE

(1183) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1184) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1185) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1186) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1187) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1188) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 3 + x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1189) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1190) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(O(x), y) → D1(x, y)
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 2·x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1191) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1192) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 2·x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = 2 + x1·x2 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(1193) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1194) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(1195) Obligation:

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

D1(N(x), F(y, z)) → D1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1196) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

U(O(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
D(O(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B) = 2   
POL(D(x1, x2)) = 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 2 + 2·x1   
POL(U(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(1197) Obligation:

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

D1(N(x), F(y, z)) → D1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1198) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

D1(N(x), F(y, z)) → D1(y, z)


Used ordering: Polynomial interpretation [POLO]:

POL(B) = 0   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 2·x1   
POL(U(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(1199) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1200) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(1201) YES

(1202) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1203) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1204) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 2   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x12   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2 + x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1205) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1206) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2·x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 3 + x1   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + 3·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1207) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1208) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1209) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1210) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + 3·x1   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(1211) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1212) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1213) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1214) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + x1 + x2   
POL(D1(x1, x2)) = x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 3 + x1   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1215) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1216) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 2·x2   
POL(F1(x1, x2)) = x1·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 3 + 3·x1   
POL(U(x1, x2)) = 2 + x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1217) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1218) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1219) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1220) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + 3·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1221) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1222) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1223) TRUE

(1224) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1225) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1226) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1227) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1228) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1229) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1230) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1231) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1232) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1233) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3·x1 + 2·x2   
POL(D1(x1, x2)) = x1   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3·x1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1234) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1235) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = x1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2·x1 + x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1236) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1237) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1238) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1239) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1240) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1241) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + x1 + x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1242) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1243) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1244) TRUE

(1245) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1246) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1247) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1248) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + 3·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 2   
POL(top(x1)) = 0   

(1249) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1250) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1251) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
D(O(x), y) → D(x, y)
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1252) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
D(O(x), y) → D(x, y)
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 3 + x1   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1253) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1254) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1255) TRUE

(1256) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1257) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1258) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1259) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1260) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1261) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1262) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1263) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1264) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1265) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1266) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(O(x), F(y, z)) → F(x, D(y, z))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1267) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(O(x), F(y, z)) → F(x, D(y, z))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1268) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1269) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 3·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + 3·x1·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3·x1 + 3·x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1270) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1271) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1272) TRUE

(1273) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1274) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1275) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1276) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1277) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1278) TRUE

(1279) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1280) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1281) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1282) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2·x1   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = 3·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 3·x1   

(1283) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1284) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
3 Lassos,
Result: This relative DT problem is equivalent to 3 subproblems.

(1285) Complex Obligation (AND)

(1286) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1287) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1288) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1289) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1290) TRUE

(1291) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1292) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1293) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1294) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1295) TRUE

(1296) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1297) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1298) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1299) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1300) TRUE

(1301) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1302) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1303) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1304) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1305) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 3·x1   

(1306) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1307) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1308) TRUE

(1309) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1310) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1311) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1312) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1313) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1314) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1315) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1316) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1317) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = x1   
POL(D(x1, x2)) = x1 + x2   
POL(D1(x1, x2)) = x1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1318) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1319) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1320) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1321) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:

Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + x1·x2   
POL(N(x1)) = 1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 1 + x1 + x12   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1322) Obligation:

Relative ADP Problem with
No absolute ADPs, and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1323) DAbsisEmptyProof (EQUIVALENT transformation)

The RDT Problem has an empty P_abs. Hence, no infinite chain exists.

(1324) YES

(1325) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1326) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1327) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1328) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1329) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1330) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1331) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1332) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1333) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1334) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1335) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1336) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1337) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1338) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1339) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1340) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1341) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U1(x, F(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1342) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U1(x, F(E, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(U1(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1343) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1344) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1345) TRUE

(1346) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1347) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1348) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1349) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1350) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1351) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1352) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + 3·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x1 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1353) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1354) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1355) TRUE

(1356) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1357) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1358) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1359) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1360) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1361) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1362) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(U(x, y)) → U1(CHECK(x), y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 3 + x1 + x12   
POL(U(x1, x2)) = 2 + 2·x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1363) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1364) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1365) TRUE

(1366) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1367) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 3·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1368) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1369) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1370) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1371) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1372) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1373) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1374) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1375) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1376) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1377) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(1378) Obligation:

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

D1(E, F(x, y)) → D1(x, y)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1379) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

D1(E, F(x, y)) → D1(x, y)


Used ordering: Polynomial interpretation [POLO]:

POL(B) = 0   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 2·x1   
POL(U(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(1380) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1381) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(1382) YES

(1383) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1384) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1385) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

U(O(x), y) → U(x, y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
F(ok(x), y) → ok(F1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1 + 3·x1 + 3·x12   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 3 + x1   
POL(top(x1)) = 0   

(1386) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1387) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 3·x1   
POL(TOP(x1)) = 3 + 2·x1   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1388) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1389) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1390) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1391) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 1 + x1 + x2   
POL(D1(x1, x2)) = 2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x1 + x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1392) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1393) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1394) TRUE

(1395) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1396) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1397) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1398) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1399) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + x2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1400) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1401) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1402) TRUE

(1403) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1404) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1405) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1406) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1407) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1408) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1409) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 2 + 2·x1   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1410) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1411) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 2 + x1 + x12   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1412) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1413) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1414) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1415) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 3 + x1 + x2   
POL(D1(x1, x2)) = 3   
POL(E) = 1   
POL(E1) = 0   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 3   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1416) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1417) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
3 Lassos,
Result: This relative DT problem is equivalent to 3 subproblems.

(1418) Complex Obligation (AND)

(1419) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1420) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 3 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = 2 + x1 + 2·x2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1421) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1422) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1423) TRUE

(1424) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1425) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 3 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = 2 + x1 + 2·x2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1426) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1427) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1428) TRUE

(1429) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1430) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 3 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = 2 + x1 + 2·x2   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1431) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1432) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1433) TRUE

(1434) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1435) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1436) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1437) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1438) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1439) TRUE

(1440) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1441) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1442) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1443) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1444) TRUE

(1445) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1446) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1447) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1448) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1449) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1450) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1451) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + x2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1452) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1453) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1454) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1455) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U1(x, F(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1456) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1457) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1458) TRUE

(1459) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1460) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1461) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1462) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1463) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1464) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1465) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1466) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1467) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1468) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1469) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1470) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1471) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1472) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = x1   
POL(D(x1, x2)) = x1 + x2   
POL(D1(x1, x2)) = x1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1473) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1474) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1475) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1476) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:

Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + x1·x2   
POL(N(x1)) = 1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 1 + x1 + x12   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1477) Obligation:

Relative ADP Problem with
No absolute ADPs, and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1478) DAbsisEmptyProof (EQUIVALENT transformation)

The RDT Problem has an empty P_abs. Hence, no infinite chain exists.

(1479) YES

(1480) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1481) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1482) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 3   
POL(E1) = 1   
POL(F(x1, x2)) = 1 + x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 3   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1483) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1484) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1485) TRUE

(1486) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1487) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1488) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1489) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1490) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1491) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 1 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 1 + 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1492) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1493) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
3 Lassos,
Result: This relative DT problem is equivalent to 3 subproblems.

(1494) Complex Obligation (AND)

(1495) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1496) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1497) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1498) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1499) TRUE

(1500) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1501) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1502) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1503) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1504) TRUE

(1505) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1506) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1507) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1508) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1509) TRUE

(1510) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1511) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1512) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1513) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1514) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1515) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1516) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 2·x12   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1517) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1518) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1519) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1520) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1521) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1522) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3 + 3·x1 + 3·x12   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 2 + x1   
POL(top(x1)) = 0   

(1523) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1524) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1525) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1526) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1527) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U1(x, F(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1528) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(E, y)) → U1(x, F(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 1 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1529) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U1(x, F(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1530) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1531) TRUE

(1532) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1533) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1534) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1535) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1536) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1537) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1538) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1539) TRUE

(1540) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1541) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1542) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1543) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U1(x, F(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1544) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1545) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1546) TRUE

(1547) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1548) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1549) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1550) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1551) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1552) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1553) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1554) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1555) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1556) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1557) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1558) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1559) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1560) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1561) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1562) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1563) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1564) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 2·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1565) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1566) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 3·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x2   
POL(F1(x1, x2)) = x1·x2   
POL(N(x1)) = 3   
POL(N1(x1)) = 2   
POL(O(x1)) = 0   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = x1   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1567) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1568) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1569) TRUE

(1570) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1571) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1572) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1573) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1574) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1575) TRUE

(1576) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1577) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1578) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1579) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1580) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1581) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1582) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1583) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1584) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1585) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1586) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1587) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1588) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(U1(x1, x2)) = 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 2·x1   

(1589) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1590) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1591) TRUE

(1592) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1593) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1594) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1595) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1596) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1597) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1598) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1599) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(1600) Obligation:

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

D1(O(x), F(y, z)) → D1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1601) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

D1(O(x), F(y, z)) → D1(y, z)

Strictly oriented rules of the TRS R:

U(O(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
D(O(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 1   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(O(x1)) = 1 + 2·x1   
POL(U(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = x1   

(1602) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1603) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(1604) YES

(1605) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1606) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1607) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3   
POL(O1(x1)) = 0   
POL(TOP(x1)) = x12   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1608) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1609) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1610) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1611) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F1(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1612) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1613) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1614) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1615) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1616) TRUE

(1617) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1618) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1619) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1620) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1621) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1622) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1623) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1624) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1625) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1626) RelADPDerelatifyingProof (EQUIVALENT transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

(1627) Obligation:

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

F1(x, U(O(y), z)) → F1(y, z)

The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1628) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

F1(x, U(O(y), z)) → F1(y, z)

Strictly oriented rules of the TRS R:

U(O(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
D(O(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))

Used ordering: Polynomial interpretation [POLO]:

POL(B) = 2   
POL(D(x1, x2)) = 2 + x1 + 2·x2   
POL(E) = 0   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x1 + x2   
POL(N(x1)) = 2·x1   
POL(O(x1)) = 1 + 2·x1   
POL(U(x1, x2)) = 2 + x1 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 2·x1   

(1629) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(F(x, y)) → F(check(x), y)
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1630) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(1631) YES

(1632) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1633) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1634) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

U(O(x), y) → U(x, y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
F(ok(x), y) → ok(F1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 0   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3 + x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1635) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1636) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1637) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1638) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1639) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1640) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1641) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1642) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1643) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E1, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 1   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1644) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1645) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1646) TRUE

(1647) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1648) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1649) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1650) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1651) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1652) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x12   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2 + x1 + x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1653) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1654) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1655) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1656) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 3·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2·x1 + x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1657) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1658) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 1   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x12   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1659) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1660) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = x1 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1661) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1662) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1663) TRUE

(1664) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1665) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1666) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1667) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1668) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1669) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1670) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1671) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:
none


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 1 + x1 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x12   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 2·x1 + 2·x1·x2 + x2   
POL(check(x1)) = 3 + 2·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(1672) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1673) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1674) TRUE

(1675) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1676) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1677) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 2·x1 + x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1678) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1679) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
3 Lassos,
Result: This relative DT problem is equivalent to 3 subproblems.

(1680) Complex Obligation (AND)

(1681) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1682) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1683) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1684) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1685) TRUE

(1686) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1687) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1688) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1689) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1690) TRUE

(1691) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1692) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D1(x, CHECK(y))
D(O(x), y) → D(x, y)
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 1 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1693) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1694) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1695) TRUE

(1696) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1697) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1698) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2·x1   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = 3·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 3·x1   

(1699) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1700) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
3 Lassos,
Result: This relative DT problem is equivalent to 3 subproblems.

(1701) Complex Obligation (AND)

(1702) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1703) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1704) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1705) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1706) TRUE

(1707) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1708) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1709) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1710) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1711) TRUE

(1712) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1713) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = x12   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1714) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
D(O(x), y) → D(x, y)
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1715) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1716) TRUE

(1717) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1718) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1719) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1720) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1721) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1722) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1723) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1724) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1725) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1726) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1727) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1728) TRUE

(1729) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1730) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1731) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1732) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1733) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1734) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1735) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1736) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2 + x12   
POL(TOP(x1)) = x12   
POL(U(x1, x2)) = 2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1737) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1738) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3·x1 + 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 3 + x1 + x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1739) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1740) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1741) TRUE

(1742) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1743) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1744) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1745) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1746) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1747) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1748) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1749) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1750) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1751) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1752) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1753) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

U(O(x), y) → U(x, y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
F(ok(x), y) → ok(F1(x, y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1 + 3·x1 + 3·x12   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 3 + x1   
POL(top(x1)) = 0   

(1754) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U(x, F1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1755) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1756) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(1757) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1758) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 2 + 2·x12   
POL(U(x1, x2)) = 0   
POL(U1(x1, x2)) = 2 + 2·x1   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1759) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1760) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 2 + x1 + 3·x2   
POL(D1(x1, x2)) = 3·x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 2 + x1 + x12   
POL(U(x1, x2)) = 2   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1761) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1762) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
3 Lassos,
Result: This relative DT problem is equivalent to 4 subproblems.

(1763) Complex Obligation (AND)

(1764) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1765) RelADPCleverAfsProof (SOUND transformation)

We use the first derelatifying processor [IJCAR24].
There are no annotations in relative ADPs, so the relative ADP problem can be transformed into a non-relative DP problem.

Furthermore, We use an argument filter [LPAR04].
Filtering:O_1 = N_1 = E = top_1 = check_1 = B = D^1_2 = 0 U_2 = 0 F_2 = 0 ok_1 = D_2 = 0
Found this filtering by looking at the following order that orders at least one DP strictly:Combined order from the following AFS and order.
D1(x1, x2)  =  D1(x2)
E  =  E
F(x1, x2)  =  F(x2)
U(x1, x2)  =  U(x2)
N(x1)  =  x1
O(x1)  =  x1
D(x1, x2)  =  D(x2)
B  =  B

Recursive path order with status [RPO].
Quasi-Precedence:

D1 > [F1, U1] > E
D1 > B

Status:
D^11: [1]
E: multiset
F1: [1]
U1: [1]
D1: [1]
B: multiset

(1766) Obligation:

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

D1(F(y)) → D1(y)

The TRS R consists of the following rules:

F(y) → ok0(F(y))
top0(ok0(U(y))) → top0(check0(D(y)))
O0(ok0(x)) → ok0(O0(x))
F(U(z)) → U(F(z))
U(y) → ok0(U(y))
check0(U(y)) → U(y)
D(y) → ok0(D(y))
U(y) → U(y)
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F(y)) → F(y)
check0(D(y)) → D(check0(y))
F(ok0(y)) → ok0(F(y))
E0 → N0(E0)
D(B0) → U(B0)
D(F(y)) → F(D(y))
check0(N0(x)) → N0(check0(x))
check0(D(y)) → D(y)
check0(F(y)) → F(check0(y))
check0(U(y)) → U(check0(y))
D(y) → D(y)
check0(O0(x)) → O0(check0(x))
D(ok0(y)) → ok0(D(y))
U(ok0(y)) → ok0(U(y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1767) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

D1(F(y)) → D1(y)


Used ordering: Polynomial interpretation [POLO]:

POL(B0) = 0   
POL(D(x1)) = x1   
POL(D1(x1)) = x1   
POL(E0) = 2   
POL(F(x1)) = 2 + 2·x1   
POL(N0(x1)) = x1   
POL(O0(x1)) = 2 + x1   
POL(U(x1)) = x1   
POL(check0(x1)) = x1   
POL(ok0(x1)) = x1   
POL(top0(x1)) = x1   

(1768) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

F(y) → ok0(F(y))
top0(ok0(U(y))) → top0(check0(D(y)))
O0(ok0(x)) → ok0(O0(x))
F(U(z)) → U(F(z))
U(y) → ok0(U(y))
check0(U(y)) → U(y)
D(y) → ok0(D(y))
U(y) → U(y)
N0(ok0(x)) → ok0(N0(x))
check0(O0(x)) → ok0(O0(x))
check0(F(y)) → F(y)
check0(D(y)) → D(check0(y))
F(ok0(y)) → ok0(F(y))
E0 → N0(E0)
D(B0) → U(B0)
D(F(y)) → F(D(y))
check0(N0(x)) → N0(check0(x))
check0(D(y)) → D(y)
check0(F(y)) → F(check0(y))
check0(U(y)) → U(check0(y))
D(y) → D(y)
check0(O0(x)) → O0(check0(x))
D(ok0(y)) → ok0(D(y))
U(ok0(y)) → ok0(U(y))

Q is empty.
We have to consider all (P,Q,R)-chains.

(1769) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(1770) YES

(1771) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1772) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x2   
POL(D1(x1, x2)) = x1   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 2   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1773) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1774) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x2   
POL(D1(x1, x2)) = 1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 2   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2 + x1·x2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1775) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1776) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3·x1   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1777) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1778) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1779) TRUE

(1780) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1781) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x2   
POL(D1(x1, x2)) = x1   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 2   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1782) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1783) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x2   
POL(D1(x1, x2)) = 1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 2   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2 + x1·x2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1784) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1785) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3·x1   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1786) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1787) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1788) TRUE

(1789) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1790) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 2·x2   
POL(D1(x1, x2)) = x1   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 2   
POL(U(x1, x2)) = 2   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = 3 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1791) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1792) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(E, F(x, y)) → F(E, D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x2   
POL(D1(x1, x2)) = 1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 2   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3 + x2   
POL(U1(x1, x2)) = 2 + x1·x2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1793) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1794) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(F(x, y)) → F1(x, CHECK(y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 3·x1   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1795) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1796) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1797) TRUE

(1798) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1799) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1800) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2 + 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1801) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1802) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1803) TRUE

(1804) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1805) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
D(x, ok(y)) → ok(D(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 3 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 2·x12   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1806) Obligation:

Relative ADP Problem with
absolute ADPs:

D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1807) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1808) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U1(x, F(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 2 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1809) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1810) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1811) TRUE

(1812) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1813) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1814) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 1   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1815) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1816) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 3·x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = 3·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 3·x1   
POL(TOP(x1)) = 3   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 3·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1817) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1818) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1819) TRUE

(1820) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U1(x, F(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1821) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U1(x, F(E, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 3 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(U1(x1, x2)) = 3·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1822) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1823) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1824) TRUE

(1825) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1826) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1827) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1828) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U1(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 3·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1829) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1830) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1831) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1832) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1833) TRUE

(1834) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1835) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1836) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U1(x, F(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F1(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
F(ok(x), y) → ok(F1(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1837) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

F(x, U(E, y)) → U1(x, F(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
check(N(x)) → N1(CHECK(x))
F(ok(x), y) → ok(F1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 3·x1   
POL(D(x1, x2)) = 1 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + 3·x2   
POL(U1(x1, x2)) = 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1838) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(E, y)) → U1(x, F(E, y))
top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F1(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
E → N(E)
F(ok(x), y) → ok(F1(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1839) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1840) TRUE

(1841) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1842) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1843) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1844) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1845) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1846) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1847) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1848) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
U(O(x), y) → U(x, y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
D(ok(x), y) → ok(D1(x, y))
check(U(x, y)) → U1(CHECK(x), y)
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 1 + 3·x1 + x2   
POL(D1(x1, x2)) = 1 + 2·x1   
POL(E) = 1   
POL(E1) = 0   
POL(F(x1, x2)) = 3 + 3·x1 + x2   
POL(F1(x1, x2)) = 3 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 3·x1 + x2   
POL(U1(x1, x2)) = 1   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1849) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(F(x, y)) → F1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1850) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1851) TRUE

(1852) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1853) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1854) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1855) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2 + x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1856) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1857) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1858) TRUE

(1859) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1860) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1861) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1862) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1863) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 1 + 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1864) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1865) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1866) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1867) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 3   
POL(top(x1)) = 0   

(1868) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1869) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2·x1 + 2·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + x2   
POL(F1(x1, x2)) = x1·x2 + 3·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1870) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1871) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + x2   
POL(D1(x1, x2)) = x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 0   
POL(N1(x1)) = x12   
POL(O(x1)) = x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 2 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1872) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1873) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(O(x), y) → D1(x, y)


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 1 + x1   
POL(D(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2·x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + x1 + x2   
POL(U1(x1, x2)) = 2·x1·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 1 + x1   
POL(top(x1)) = 0   

(1874) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1875) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1876) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1877) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1878) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1879) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U1(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
check(F(x, y)) → F1(CHECK(x), y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(D(x, y)) → D1(x, CHECK(y))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 3·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = 2·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1880) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1881) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U(x, check(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 2 + x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1882) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1883) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1884) TRUE

(1885) Obligation:

Relative ADP Problem with
absolute ADPs:

F(x, U(O(y), z)) → U1(x, F(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1886) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U1(x, F(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1887) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1888) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1889) TRUE

(1890) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1891) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1892) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1893) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = 0   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1894) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1895) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1896) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1897) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 2·x2   
POL(F1(x1, x2)) = 3·x1 + x1·x2   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x12   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1 + 2·x1 + x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1898) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1899) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(O(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 3·x1 + 2·x2   
POL(F1(x1, x2)) = x2   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 1 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1900) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1901) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + x1·x2 + x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1902) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1903) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = 2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = 1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 2 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(U1(x1, x2)) = 2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1904) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1905) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))

Relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 2   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 2 + 3·x2   
POL(D1(x1, x2)) = 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x2   
POL(F1(x1, x2)) = 2 + 2·x1   
POL(N(x1)) = 3   
POL(N1(x1)) = 2 + x1   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 1 + 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1906) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(N(x)) → N(check(x))
D(x, B) → U(x, B)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1907) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1908) TRUE

(1909) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1910) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1911) Obligation:

Relative ADP Problem with
absolute ADPs:

D(O(x), F(y, z)) → F(x, D1(y, z))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1912) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D1(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + 3·x1   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 2·x1 + 2·x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = 2·x1   
POL(O(x1)) = 2 + 3·x1   
POL(O1(x1)) = 3·x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = x1   
POL(ok(x1)) = 1   
POL(top(x1)) = 0   

(1913) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))

(1914) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1915) TRUE

(1916) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1917) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(O(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = 2 + 2·x2   
POL(E) = 3   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + x1 + 3·x2   
POL(F1(x1, x2)) = 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 3·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1918) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(N(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1919) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1920) TRUE

(1921) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1922) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1923) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1924) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

Relative ADPs:

check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
D(ok(x), y) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 2·x1   
POL(D(x1, x2)) = 3 + 3·x1 + 2·x2   
POL(D1(x1, x2)) = 3·x1 + x2   
POL(E) = 3   
POL(E1) = 0   
POL(F(x1, x2)) = 2 + 3·x1 + x2   
POL(F1(x1, x2)) = 1 + 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 3·x1 + x2   
POL(U1(x1, x2)) = 2·x1   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1925) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(ok(x), y) → ok(D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, ok(y)) → ok(D(x, y))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1926) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1927) TRUE

(1928) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1929) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1930) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1931) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1932) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1933) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F(E1, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1934) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1935) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Relative ADPs:


check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(F(x, y)) → F1(x, CHECK(y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = 2 + 2·x1   
POL(D(x1, x2)) = 3 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 3 + 3·x1 + 3·x2   
POL(F1(x1, x2)) = x1   
POL(N(x1)) = 3·x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 3 + 3·x1   
POL(O1(x1)) = x1   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + 2·x1 + 2·x2   
POL(U1(x1, x2)) = 0   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1936) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1937) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
1 SCC with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 1 subproblem.

(1938) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))

(1939) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = 1 + 2·x1 + 3·x2   
POL(D1(x1, x2)) = 0   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + 2·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + 2·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 2·x1   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = 0   
POL(top(x1)) = 0   

(1940) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1941) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(O(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 0   
POL(CHECK(x1)) = 0   
POL(D(x1, x2)) = 1 + 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 2 + x12   
POL(O(x1)) = 3 + x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 1   
POL(U1(x1, x2)) = 2·x1·x2 + 2·x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1942) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
D(N(x), y) → D1(x, y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(O(x), F(y, z)) → F(x, D(y, z))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))

(1943) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(x, B) → U(x, B)

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
N(ok(x)) → ok(N(x))
D(O(x), F(y, z)) → F(x, D(y, z))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))
check(D(x, y)) → D(x, check(y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2   
POL(D(x1, x2)) = x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 2   
POL(E1) = 3   
POL(F(x1, x2)) = x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1   
POL(N(x1)) = x1   
POL(N1(x1)) = 2   
POL(O(x1)) = 2 + 2·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = x1 + 2·x2   
POL(U1(x1, x2)) = 2 + 2·x1 + 2·x1·x2 + 2·x2   
POL(check(x1)) = 2·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1944) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1945) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


D(E, F(x, y)) → F(E, D1(x, y))
D(E, F(x, y)) → F(E, D(x, y))

Relative ADPs:

F(x, ok(y)) → ok(F(x, y))
F(ok(x), y) → ok(F(x, y))
E → N(E)
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
U(O(x), y) → U(x, y)
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
check(U(x, y)) → U(x, check(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(O(x)) → O(check(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
check(D(x, y)) → D(x, check(y))
F(x, U(E, y)) → U(x, F(E, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

Relative ADPs:

D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 1   
POL(CHECK(x1)) = 2 + x1   
POL(D(x1, x2)) = 3·x1 + 3·x2   
POL(D1(x1, x2)) = x1 + 3·x2   
POL(E) = 1   
POL(E1) = 3   
POL(F(x1, x2)) = 3·x1 + 3·x2   
POL(F1(x1, x2)) = 2·x1 + 3·x1·x2   
POL(N(x1)) = x1   
POL(N1(x1)) = x1   
POL(O(x1)) = 1 + 3·x1   
POL(O1(x1)) = 2   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3·x1 + 3·x2   
POL(U1(x1, x2)) = 2 + 2·x2   
POL(check(x1)) = 3·x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1946) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
D(N(x), y) → D1(x, y)
U(N(x), y) → U(x, y)
N(ok(x)) → ok(N(x))
check(F(x, y)) → F(check(x), y)
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
D(x, B) → U(x, B)
check(N(x)) → N(check(x))
check(D(x, y)) → D(check(x), y)
check(F(x, y)) → F(x, check(y))
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1947) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1948) TRUE

(1949) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F(x, D1(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1950) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1951) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(x, ok(y)) → ok(D(x, y))
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1952) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(N(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1953) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1954) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(O(x), F(y, z)) → F1(x, D(y, z))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1955) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1956) RelADPReductionPairProof (EQUIVALENT transformation)

We use the reduction pair processor [IJCAR24].
The following rules can be oriented strictly (l^# > ann(r))
and therefore we can remove all of its annotations in the right-hand side:
Absolute ADPs:


F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

Relative ADPs:

check(D(x, y)) → D1(CHECK(x), y)
F(x, ok(y)) → ok(F(x, y))
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(O(x)) → O1(CHECK(x))
U(O(x), y) → U(x, y)
check(U(x, y)) → U1(x, CHECK(y))
check(D(x, y)) → D1(x, CHECK(y))
U(N(x), y) → U(x, y)
D(O(x), y) → D(x, y)
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))


The remaining rules can at least be oriented weakly:
Absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U1(x, B)

Relative ADPs:

check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
check(F(x, y)) → F1(x, CHECK(y))


Ordered with Polynomial interpretation [POLO]:

POL(B) = 3   
POL(CHECK(x1)) = x1   
POL(D(x1, x2)) = 3 + x1 + 3·x2   
POL(D1(x1, x2)) = x2   
POL(E) = 0   
POL(E1) = 3   
POL(F(x1, x2)) = 2 + x1 + 2·x2   
POL(F1(x1, x2)) = 2   
POL(N(x1)) = 2·x1   
POL(N1(x1)) = 0   
POL(O(x1)) = 3 + 2·x1   
POL(O1(x1)) = 0   
POL(TOP(x1)) = 0   
POL(U(x1, x2)) = 3 + x1 + 2·x2   
POL(U1(x1, x2)) = x2   
POL(check(x1)) = x1   
POL(ok(x1)) = x1   
POL(top(x1)) = 0   

(1957) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(x, B) → U1(x, B)

and relative ADPs:

F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
F(x, U(N(y), z)) → U(x, F(y, z))
U(ok(x), y) → ok(U(x, y))
check(U(x, y)) → U(check(x), y)
D(ok(x), y) → ok(D(x, y))
U(O(x), y) → U(x, y)
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
F(x, U(O(y), z)) → U(x, F(y, z))
N(ok(x)) → ok(N(x))
check(O(x)) → ok(O(x))
check(D(x, y)) → D(x, check(y))
F(x, ok(y)) → ok(F(x, y))
E → N(E)
D(E, F(x, y)) → F(E, D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
check(D(x, y)) → D(check(x), y)
D(x, ok(y)) → ok(D1(x, y))
check(U(x, y)) → U(x, check(y))
D(O(x), y) → D(x, y)
check(O(x)) → O(check(x))
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
U(x, ok(y)) → ok(U(x, y))
F(x, U(E, y)) → U(x, F(E, y))

(1958) RelADPDepGraphProof (EQUIVALENT transformation)

We use the relative dependency graph processor [IJCAR24].
The approximation of the Relative Dependency Graph contains:
0 SCCs with nodes from P_abs,
0 Lassos,
Result: This relative DT problem is equivalent to 0 subproblems.

(1959) TRUE

(1960) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1961) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
D(E, F(x, y)) → F1(E, D(x, y))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
D(N(x), y) → D(x, y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1962) Obligation:

Relative ADP Problem with
absolute ADPs:

D(E, F(x, y)) → F(E, D1(x, y))
top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(N(x), F(y, z)) → F(x, D(y, z))
D(x, B) → U(x, B)
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1963) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))

(1964) Obligation:

Relative ADP Problem with
absolute ADPs:

top(ok(U(x, y))) → top(check(D(x, y)))
F(x, U(N(y), z)) → U(x, F(y, z))
F(x, U(O(y), z)) → U(x, F(y, z))
D(x, B) → U1(x, B)
D(N(x), F(y, z)) → F(x, D(y, z))
D(O(x), F(y, z)) → F(x, D(y, z))
D(E, F(x, y)) → F(E, D(x, y))
F(x, U(E, y)) → U(x, F(E, y))

and relative ADPs:

F(x, ok(y)) → ok(F(x, y))
check(D(x, y)) → D1(CHECK(x), y)
E → N(E)
F(ok(x), y) → ok(F(x, y))
O(ok(x)) → ok(O(x))
D(O(x), y) → D1(x, y)
U(ok(x), y) → ok(U(x, y))
D(ok(x), y) → ok(D1(x, y))
check(F(x, y)) → F1(x, CHECK(y))
U(O(x), y) → U(x, y)
check(O(x)) → O1(CHECK(x))
check(F(x, y)) → F1(CHECK(x), y)
D(N(x), y) → D1(x, y)
check(U(x, y)) → U1(x, CHECK(y))
D(x, ok(y)) → ok(D1(x, y))
check(N(x)) → N1(CHECK(x))
U(N(x), y) → U(x, y)
check(D(x, y)) → D1(x, CHECK(y))
N(ok(x)) → ok(N(x))
check(U(x, y)) → U1(CHECK(x), y)
check(O(x)) → ok(O(x))
U(x, ok(y)) → ok(U(x, y))