/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


YES

Check SN using TTT2 (University of Innsbruck)

Problem:
 and(P,forall(Q)) -> forall(and(P,Q))
 or(P,forall(Q)) -> forall(or(P,Q))
 and(forall(Q),P) -> forall(and(Q,P))
 or(forall(Q),P) -> forall(or(Q,P))
 not(forall(Q)) -> exists(not(Q))
 and(P,exists(Q)) -> exists(and(P,Q))
 or(P,exists(Q)) -> exists(or(P,Q))
 and(exists(Q),P) -> exists(and(Q,P))
 or(exists(Q),P) -> exists(or(Q,P))
 not(exists(Q)) -> forall(not(Q))

Proof:
 DP Processor:
  DPs:
   and#(P,forall(Q)) -> and#(P,Q)
   or#(P,forall(Q)) -> or#(P,Q)
   and#(forall(Q),P) -> and#(Q,P)
   or#(forall(Q),P) -> or#(Q,P)
   not#(forall(Q)) -> not#(Q)
   and#(P,exists(Q)) -> and#(P,Q)
   or#(P,exists(Q)) -> or#(P,Q)
   and#(exists(Q),P) -> and#(Q,P)
   or#(exists(Q),P) -> or#(Q,P)
   not#(exists(Q)) -> not#(Q)
  TRS:
   and(P,forall(Q)) -> forall(and(P,Q))
   or(P,forall(Q)) -> forall(or(P,Q))
   and(forall(Q),P) -> forall(and(Q,P))
   or(forall(Q),P) -> forall(or(Q,P))
   not(forall(Q)) -> exists(not(Q))
   and(P,exists(Q)) -> exists(and(P,Q))
   or(P,exists(Q)) -> exists(or(P,Q))
   and(exists(Q),P) -> exists(and(Q,P))
   or(exists(Q),P) -> exists(or(Q,P))
   not(exists(Q)) -> forall(not(Q))
  TDG Processor:
   DPs:
    and#(P,forall(Q)) -> and#(P,Q)
    or#(P,forall(Q)) -> or#(P,Q)
    and#(forall(Q),P) -> and#(Q,P)
    or#(forall(Q),P) -> or#(Q,P)
    not#(forall(Q)) -> not#(Q)
    and#(P,exists(Q)) -> and#(P,Q)
    or#(P,exists(Q)) -> or#(P,Q)
    and#(exists(Q),P) -> and#(Q,P)
    or#(exists(Q),P) -> or#(Q,P)
    not#(exists(Q)) -> not#(Q)
   TRS:
    and(P,forall(Q)) -> forall(and(P,Q))
    or(P,forall(Q)) -> forall(or(P,Q))
    and(forall(Q),P) -> forall(and(Q,P))
    or(forall(Q),P) -> forall(or(Q,P))
    not(forall(Q)) -> exists(not(Q))
    and(P,exists(Q)) -> exists(and(P,Q))
    or(P,exists(Q)) -> exists(or(P,Q))
    and(exists(Q),P) -> exists(and(Q,P))
    or(exists(Q),P) -> exists(or(Q,P))
    not(exists(Q)) -> forall(not(Q))
   graph:
    not#(exists(Q)) -> not#(Q) -> not#(exists(Q)) -> not#(Q)
    not#(exists(Q)) -> not#(Q) -> not#(forall(Q)) -> not#(Q)
    not#(forall(Q)) -> not#(Q) -> not#(exists(Q)) -> not#(Q)
    not#(forall(Q)) -> not#(Q) -> not#(forall(Q)) -> not#(Q)
    or#(exists(Q),P) -> or#(Q,P) -> or#(exists(Q),P) -> or#(Q,P)
    or#(exists(Q),P) -> or#(Q,P) -> or#(P,exists(Q)) -> or#(P,Q)
    or#(exists(Q),P) -> or#(Q,P) -> or#(forall(Q),P) -> or#(Q,P)
    or#(exists(Q),P) -> or#(Q,P) -> or#(P,forall(Q)) -> or#(P,Q)
    or#(forall(Q),P) -> or#(Q,P) -> or#(exists(Q),P) -> or#(Q,P)
    or#(forall(Q),P) -> or#(Q,P) -> or#(P,exists(Q)) -> or#(P,Q)
    or#(forall(Q),P) -> or#(Q,P) -> or#(forall(Q),P) -> or#(Q,P)
    or#(forall(Q),P) -> or#(Q,P) -> or#(P,forall(Q)) -> or#(P,Q)
    or#(P,exists(Q)) -> or#(P,Q) -> or#(exists(Q),P) -> or#(Q,P)
    or#(P,exists(Q)) -> or#(P,Q) -> or#(P,exists(Q)) -> or#(P,Q)
    or#(P,exists(Q)) -> or#(P,Q) -> or#(forall(Q),P) -> or#(Q,P)
    or#(P,exists(Q)) -> or#(P,Q) -> or#(P,forall(Q)) -> or#(P,Q)
    or#(P,forall(Q)) -> or#(P,Q) -> or#(exists(Q),P) -> or#(Q,P)
    or#(P,forall(Q)) -> or#(P,Q) -> or#(P,exists(Q)) -> or#(P,Q)
    or#(P,forall(Q)) -> or#(P,Q) -> or#(forall(Q),P) -> or#(Q,P)
    or#(P,forall(Q)) -> or#(P,Q) -> or#(P,forall(Q)) -> or#(P,Q)
    and#(exists(Q),P) -> and#(Q,P) -> and#(exists(Q),P) -> and#(Q,P)
    and#(exists(Q),P) -> and#(Q,P) -> and#(P,exists(Q)) -> and#(P,Q)
    and#(exists(Q),P) -> and#(Q,P) -> and#(forall(Q),P) -> and#(Q,P)
    and#(exists(Q),P) -> and#(Q,P) -> and#(P,forall(Q)) -> and#(P,Q)
    and#(forall(Q),P) -> and#(Q,P) -> and#(exists(Q),P) -> and#(Q,P)
    and#(forall(Q),P) -> and#(Q,P) -> and#(P,exists(Q)) -> and#(P,Q)
    and#(forall(Q),P) -> and#(Q,P) -> and#(forall(Q),P) -> and#(Q,P)
    and#(forall(Q),P) -> and#(Q,P) -> and#(P,forall(Q)) -> and#(P,Q)
    and#(P,exists(Q)) -> and#(P,Q) -> and#(exists(Q),P) -> and#(Q,P)
    and#(P,exists(Q)) -> and#(P,Q) -> and#(P,exists(Q)) -> and#(P,Q)
    and#(P,exists(Q)) -> and#(P,Q) -> and#(forall(Q),P) -> and#(Q,P)
    and#(P,exists(Q)) -> and#(P,Q) -> and#(P,forall(Q)) -> and#(P,Q)
    and#(P,forall(Q)) -> and#(P,Q) -> and#(exists(Q),P) -> and#(Q,P)
    and#(P,forall(Q)) -> and#(P,Q) -> and#(P,exists(Q)) -> and#(P,Q)
    and#(P,forall(Q)) -> and#(P,Q) -> and#(forall(Q),P) -> and#(Q,P)
    and#(P,forall(Q)) -> and#(P,Q) -> and#(P,forall(Q)) -> and#(P,Q)
   SCC Processor:
    #sccs: 3
    #rules: 10
    #arcs: 36/100
    DPs:
     and#(exists(Q),P) -> and#(Q,P)
     and#(P,forall(Q)) -> and#(P,Q)
     and#(forall(Q),P) -> and#(Q,P)
     and#(P,exists(Q)) -> and#(P,Q)
    TRS:
     and(P,forall(Q)) -> forall(and(P,Q))
     or(P,forall(Q)) -> forall(or(P,Q))
     and(forall(Q),P) -> forall(and(Q,P))
     or(forall(Q),P) -> forall(or(Q,P))
     not(forall(Q)) -> exists(not(Q))
     and(P,exists(Q)) -> exists(and(P,Q))
     or(P,exists(Q)) -> exists(or(P,Q))
     and(exists(Q),P) -> exists(and(Q,P))
     or(exists(Q),P) -> exists(or(Q,P))
     not(exists(Q)) -> forall(not(Q))
    Subterm Criterion Processor:
     simple projection:
      pi(and#) = 0
     problem:
      DPs:
       and#(P,forall(Q)) -> and#(P,Q)
       and#(P,exists(Q)) -> and#(P,Q)
      TRS:
       and(P,forall(Q)) -> forall(and(P,Q))
       or(P,forall(Q)) -> forall(or(P,Q))
       and(forall(Q),P) -> forall(and(Q,P))
       or(forall(Q),P) -> forall(or(Q,P))
       not(forall(Q)) -> exists(not(Q))
       and(P,exists(Q)) -> exists(and(P,Q))
       or(P,exists(Q)) -> exists(or(P,Q))
       and(exists(Q),P) -> exists(and(Q,P))
       or(exists(Q),P) -> exists(or(Q,P))
       not(exists(Q)) -> forall(not(Q))
     Subterm Criterion Processor:
      simple projection:
       pi(and#) = 1
      problem:
       DPs:
        
       TRS:
        and(P,forall(Q)) -> forall(and(P,Q))
        or(P,forall(Q)) -> forall(or(P,Q))
        and(forall(Q),P) -> forall(and(Q,P))
        or(forall(Q),P) -> forall(or(Q,P))
        not(forall(Q)) -> exists(not(Q))
        and(P,exists(Q)) -> exists(and(P,Q))
        or(P,exists(Q)) -> exists(or(P,Q))
        and(exists(Q),P) -> exists(and(Q,P))
        or(exists(Q),P) -> exists(or(Q,P))
        not(exists(Q)) -> forall(not(Q))
      Qed
    
    DPs:
     or#(exists(Q),P) -> or#(Q,P)
     or#(P,forall(Q)) -> or#(P,Q)
     or#(forall(Q),P) -> or#(Q,P)
     or#(P,exists(Q)) -> or#(P,Q)
    TRS:
     and(P,forall(Q)) -> forall(and(P,Q))
     or(P,forall(Q)) -> forall(or(P,Q))
     and(forall(Q),P) -> forall(and(Q,P))
     or(forall(Q),P) -> forall(or(Q,P))
     not(forall(Q)) -> exists(not(Q))
     and(P,exists(Q)) -> exists(and(P,Q))
     or(P,exists(Q)) -> exists(or(P,Q))
     and(exists(Q),P) -> exists(and(Q,P))
     or(exists(Q),P) -> exists(or(Q,P))
     not(exists(Q)) -> forall(not(Q))
    Subterm Criterion Processor:
     simple projection:
      pi(or#) = 0
     problem:
      DPs:
       or#(P,forall(Q)) -> or#(P,Q)
       or#(P,exists(Q)) -> or#(P,Q)
      TRS:
       and(P,forall(Q)) -> forall(and(P,Q))
       or(P,forall(Q)) -> forall(or(P,Q))
       and(forall(Q),P) -> forall(and(Q,P))
       or(forall(Q),P) -> forall(or(Q,P))
       not(forall(Q)) -> exists(not(Q))
       and(P,exists(Q)) -> exists(and(P,Q))
       or(P,exists(Q)) -> exists(or(P,Q))
       and(exists(Q),P) -> exists(and(Q,P))
       or(exists(Q),P) -> exists(or(Q,P))
       not(exists(Q)) -> forall(not(Q))
     Subterm Criterion Processor:
      simple projection:
       pi(or#) = 1
      problem:
       DPs:
        
       TRS:
        and(P,forall(Q)) -> forall(and(P,Q))
        or(P,forall(Q)) -> forall(or(P,Q))
        and(forall(Q),P) -> forall(and(Q,P))
        or(forall(Q),P) -> forall(or(Q,P))
        not(forall(Q)) -> exists(not(Q))
        and(P,exists(Q)) -> exists(and(P,Q))
        or(P,exists(Q)) -> exists(or(P,Q))
        and(exists(Q),P) -> exists(and(Q,P))
        or(exists(Q),P) -> exists(or(Q,P))
        not(exists(Q)) -> forall(not(Q))
      Qed
    
    DPs:
     not#(exists(Q)) -> not#(Q)
     not#(forall(Q)) -> not#(Q)
    TRS:
     and(P,forall(Q)) -> forall(and(P,Q))
     or(P,forall(Q)) -> forall(or(P,Q))
     and(forall(Q),P) -> forall(and(Q,P))
     or(forall(Q),P) -> forall(or(Q,P))
     not(forall(Q)) -> exists(not(Q))
     and(P,exists(Q)) -> exists(and(P,Q))
     or(P,exists(Q)) -> exists(or(P,Q))
     and(exists(Q),P) -> exists(and(Q,P))
     or(exists(Q),P) -> exists(or(Q,P))
     not(exists(Q)) -> forall(not(Q))
    Subterm Criterion Processor:
     simple projection:
      pi(not#) = 0
     problem:
      DPs:
       
      TRS:
       and(P,forall(Q)) -> forall(and(P,Q))
       or(P,forall(Q)) -> forall(or(P,Q))
       and(forall(Q),P) -> forall(and(Q,P))
       or(forall(Q),P) -> forall(or(Q,P))
       not(forall(Q)) -> exists(not(Q))
       and(P,exists(Q)) -> exists(and(P,Q))
       or(P,exists(Q)) -> exists(or(P,Q))
       and(exists(Q),P) -> exists(and(Q,P))
       or(exists(Q),P) -> exists(or(Q,P))
       not(exists(Q)) -> forall(not(Q))
     Qed

...

Problem:
 and(P,forall(Q)) -> forall(and(P,Q))
 or(P,forall(Q)) -> forall(or(P,Q))
 and(forall(Q),P) -> forall(and(Q,P))
 or(forall(Q),P) -> forall(or(Q,P))
 not(forall(Q)) -> exists(not(Q))
 and(P,exists(Q)) -> exists(and(P,Q))
 or(P,exists(Q)) -> exists(or(P,Q))
 and(exists(Q),P) -> exists(and(Q,P))
 or(exists(Q),P) -> exists(or(Q,P))
 not(exists(Q)) -> forall(not(Q))

Proof:
 DP Processor:
  DPs:
   and#(P,forall(Q)) -> and#(P,Q)
   or#(P,forall(Q)) -> or#(P,Q)
   and#(forall(Q),P) -> and#(Q,P)
   or#(forall(Q),P) -> or#(Q,P)
   not#(forall(Q)) -> not#(Q)
   and#(P,exists(Q)) -> and#(P,Q)
   or#(P,exists(Q)) -> or#(P,Q)
   and#(exists(Q),P) -> and#(Q,P)
   or#(exists(Q),P) -> or#(Q,P)
   not#(exists(Q)) -> not#(Q)
  TRS:
   and(P,forall(Q)) -> forall(and(P,Q))
   or(P,forall(Q)) -> forall(or(P,Q))
   and(forall(Q),P) -> forall(and(Q,P))
   or(forall(Q),P) -> forall(or(Q,P))
   not(forall(Q)) -> exists(not(Q))
   and(P,exists(Q)) -> exists(and(P,Q))
   or(P,exists(Q)) -> exists(or(P,Q))
   and(exists(Q),P) -> exists(and(Q,P))
   or(exists(Q),P) -> exists(or(Q,P))
   not(exists(Q)) -> forall(not(Q))
  TDG Processor:
   DPs:
    and#(P,forall(Q)) -> and#(P,Q)
    or#(P,forall(Q)) -> or#(P,Q)
    and#(forall(Q),P) -> and#(Q,P)
    or#(forall(Q),P) -> or#(Q,P)
    not#(forall(Q)) -> not#(Q)
    and#(P,exists(Q)) -> and#(P,Q)
    or#(P,exists(Q)) -> or#(P,Q)
    and#(exists(Q),P) -> and#(Q,P)
    or#(exists(Q),P) -> or#(Q,P)
    not#(exists(Q)) -> not#(Q)
   TRS:
    and(P,forall(Q)) -> forall(and(P,Q))
    or(P,forall(Q)) -> forall(or(P,Q))
    and(forall(Q),P) -> forall(and(Q,P))
    or(forall(Q),P) -> forall(or(Q,P))
    not(forall(Q)) -> exists(not(Q))
    and(P,exists(Q)) -> exists(and(P,Q))
    or(P,exists(Q)) -> exists(or(P,Q))
    and(exists(Q),P) -> exists(and(Q,P))
    or(exists(Q),P) -> exists(or(Q,P))
    not(exists(Q)) -> forall(not(Q))
   graph:
    not#(exists(Q)) -> not#(Q) -> not#(exists(Q)) -> not#(Q)
    not#(exists(Q)) -> not#(Q) -> not#(forall(Q)) -> not#(Q)
    not#(forall(Q)) -> not#(Q) -> not#(exists(Q)) -> not#(Q)
    not#(forall(Q)) -> not#(Q) -> not#(forall(Q)) -> not#(Q)
    or#(exists(Q),P) -> or#(Q,P) -> or#(exists(Q),P) -> or#(Q,P)
    or#(exists(Q),P) -> or#(Q,P) -> or#(P,exists(Q)) -> or#(P,Q)
    or#(exists(Q),P) -> or#(Q,P) -> or#(forall(Q),P) -> or#(Q,P)
    or#(exists(Q),P) -> or#(Q,P) -> or#(P,forall(Q)) -> or#(P,Q)
    or#(forall(Q),P) -> or#(Q,P) -> or#(exists(Q),P) -> or#(Q,P)
    or#(forall(Q),P) -> or#(Q,P) -> or#(P,exists(Q)) -> or#(P,Q)
    or#(forall(Q),P) -> or#(Q,P) -> or#(forall(Q),P) -> or#(Q,P)
    or#(forall(Q),P) -> or#(Q,P) -> or#(P,forall(Q)) -> or#(P,Q)
    or#(P,exists(Q)) -> or#(P,Q) -> or#(exists(Q),P) -> or#(Q,P)
    or#(P,exists(Q)) -> or#(P,Q) -> or#(P,exists(Q)) -> or#(P,Q)
    or#(P,exists(Q)) -> or#(P,Q) -> or#(forall(Q),P) -> or#(Q,P)
    or#(P,exists(Q)) -> or#(P,Q) -> or#(P,forall(Q)) -> or#(P,Q)
    or#(P,forall(Q)) -> or#(P,Q) -> or#(exists(Q),P) -> or#(Q,P)
    or#(P,forall(Q)) -> or#(P,Q) -> or#(P,exists(Q)) -> or#(P,Q)
    or#(P,forall(Q)) -> or#(P,Q) -> or#(forall(Q),P) -> or#(Q,P)
    or#(P,forall(Q)) -> or#(P,Q) -> or#(P,forall(Q)) -> or#(P,Q)
    and#(exists(Q),P) -> and#(Q,P) -> and#(exists(Q),P) -> and#(Q,P)
    and#(exists(Q),P) -> and#(Q,P) -> and#(P,exists(Q)) -> and#(P,Q)
    and#(exists(Q),P) -> and#(Q,P) -> and#(forall(Q),P) -> and#(Q,P)
    and#(exists(Q),P) -> and#(Q,P) -> and#(P,forall(Q)) -> and#(P,Q)
    and#(forall(Q),P) -> and#(Q,P) -> and#(exists(Q),P) -> and#(Q,P)
    and#(forall(Q),P) -> and#(Q,P) -> and#(P,exists(Q)) -> and#(P,Q)
    and#(forall(Q),P) -> and#(Q,P) -> and#(forall(Q),P) -> and#(Q,P)
    and#(forall(Q),P) -> and#(Q,P) -> and#(P,forall(Q)) -> and#(P,Q)
    and#(P,exists(Q)) -> and#(P,Q) -> and#(exists(Q),P) -> and#(Q,P)
    and#(P,exists(Q)) -> and#(P,Q) -> and#(P,exists(Q)) -> and#(P,Q)
    and#(P,exists(Q)) -> and#(P,Q) -> and#(forall(Q),P) -> and#(Q,P)
    and#(P,exists(Q)) -> and#(P,Q) -> and#(P,forall(Q)) -> and#(P,Q)
    and#(P,forall(Q)) -> and#(P,Q) -> and#(exists(Q),P) -> and#(Q,P)
    and#(P,forall(Q)) -> and#(P,Q) -> and#(P,exists(Q)) -> and#(P,Q)
    and#(P,forall(Q)) -> and#(P,Q) -> and#(forall(Q),P) -> and#(Q,P)
    and#(P,forall(Q)) -> and#(P,Q) -> and#(P,forall(Q)) -> and#(P,Q)
   SCC Processor:
    #sccs: 3
    #rules: 10
    #arcs: 36/100
    DPs:
     and#(exists(Q),P) -> and#(Q,P)
     and#(P,forall(Q)) -> and#(P,Q)
     and#(forall(Q),P) -> and#(Q,P)
     and#(P,exists(Q)) -> and#(P,Q)
    TRS:
     and(P,forall(Q)) -> forall(and(P,Q))
     or(P,forall(Q)) -> forall(or(P,Q))
     and(forall(Q),P) -> forall(and(Q,P))
     or(forall(Q),P) -> forall(or(Q,P))
     not(forall(Q)) -> exists(not(Q))
     and(P,exists(Q)) -> exists(and(P,Q))
     or(P,exists(Q)) -> exists(or(P,Q))
     and(exists(Q),P) -> exists(and(Q,P))
     or(exists(Q),P) -> exists(or(Q,P))
     not(exists(Q)) -> forall(not(Q))
    Subterm Criterion Processor:
     simple projection:
      pi(and#) = 0
     problem:
      DPs:
       and#(P,forall(Q)) -> and#(P,Q)
       and#(P,exists(Q)) -> and#(P,Q)
      TRS:
       and(P,forall(Q)) -> forall(and(P,Q))
       or(P,forall(Q)) -> forall(or(P,Q))
       and(forall(Q),P) -> forall(and(Q,P))
       or(forall(Q),P) -> forall(or(Q,P))
       not(forall(Q)) -> exists(not(Q))
       and(P,exists(Q)) -> exists(and(P,Q))
       or(P,exists(Q)) -> exists(or(P,Q))
       and(exists(Q),P) -> exists(and(Q,P))
       or(exists(Q),P) -> exists(or(Q,P))
       not(exists(Q)) -> forall(not(Q))
     Subterm Criterion Processor:
      simple projection:
       pi(and#) = 1
      problem:
       DPs:
        
       TRS:
        and(P,forall(Q)) -> forall(and(P,Q))
        or(P,forall(Q)) -> forall(or(P,Q))
        and(forall(Q),P) -> forall(and(Q,P))
        or(forall(Q),P) -> forall(or(Q,P))
        not(forall(Q)) -> exists(not(Q))
        and(P,exists(Q)) -> exists(and(P,Q))
        or(P,exists(Q)) -> exists(or(P,Q))
        and(exists(Q),P) -> exists(and(Q,P))
        or(exists(Q),P) -> exists(or(Q,P))
        not(exists(Q)) -> forall(not(Q))
      Qed
    
    DPs:
     or#(exists(Q),P) -> or#(Q,P)
     or#(P,forall(Q)) -> or#(P,Q)
     or#(forall(Q),P) -> or#(Q,P)
     or#(P,exists(Q)) -> or#(P,Q)
    TRS:
     and(P,forall(Q)) -> forall(and(P,Q))
     or(P,forall(Q)) -> forall(or(P,Q))
     and(forall(Q),P) -> forall(and(Q,P))
     or(forall(Q),P) -> forall(or(Q,P))
     not(forall(Q)) -> exists(not(Q))
     and(P,exists(Q)) -> exists(and(P,Q))
     or(P,exists(Q)) -> exists(or(P,Q))
     and(exists(Q),P) -> exists(and(Q,P))
     or(exists(Q),P) -> exists(or(Q,P))
     not(exists(Q)) -> forall(not(Q))
    Subterm Criterion Processor:
     simple projection:
      pi(or#) = 0
     problem:
      DPs:
       or#(P,forall(Q)) -> or#(P,Q)
       or#(P,exists(Q)) -> or#(P,Q)
      TRS:
       and(P,forall(Q)) -> forall(and(P,Q))
       or(P,forall(Q)) -> forall(or(P,Q))
       and(forall(Q),P) -> forall(and(Q,P))
       or(forall(Q),P) -> forall(or(Q,P))
       not(forall(Q)) -> exists(not(Q))
       and(P,exists(Q)) -> exists(and(P,Q))
       or(P,exists(Q)) -> exists(or(P,Q))
       and(exists(Q),P) -> exists(and(Q,P))
       or(exists(Q),P) -> exists(or(Q,P))
       not(exists(Q)) -> forall(not(Q))
     Subterm Criterion Processor:
      simple projection:
       pi(or#) = 1
      problem:
       DPs:
        
       TRS:
        and(P,forall(Q)) -> forall(and(P,Q))
        or(P,forall(Q)) -> forall(or(P,Q))
        and(forall(Q),P) -> forall(and(Q,P))
        or(forall(Q),P) -> forall(or(Q,P))
        not(forall(Q)) -> exists(not(Q))
        and(P,exists(Q)) -> exists(and(P,Q))
        or(P,exists(Q)) -> exists(or(P,Q))
        and(exists(Q),P) -> exists(and(Q,P))
        or(exists(Q),P) -> exists(or(Q,P))
        not(exists(Q)) -> forall(not(Q))
      Qed
    
    DPs:
     not#(exists(Q)) -> not#(Q)
     not#(forall(Q)) -> not#(Q)
    TRS:
     and(P,forall(Q)) -> forall(and(P,Q))
     or(P,forall(Q)) -> forall(or(P,Q))
     and(forall(Q),P) -> forall(and(Q,P))
     or(forall(Q),P) -> forall(or(Q,P))
     not(forall(Q)) -> exists(not(Q))
     and(P,exists(Q)) -> exists(and(P,Q))
     or(P,exists(Q)) -> exists(or(P,Q))
     and(exists(Q),P) -> exists(and(Q,P))
     or(exists(Q),P) -> exists(or(Q,P))
     not(exists(Q)) -> forall(not(Q))
    Subterm Criterion Processor:
     simple projection:
      pi(not#) = 0
     problem:
      DPs:
       
      TRS:
       and(P,forall(Q)) -> forall(and(P,Q))
       or(P,forall(Q)) -> forall(or(P,Q))
       and(forall(Q),P) -> forall(and(Q,P))
       or(forall(Q),P) -> forall(or(Q,P))
       not(forall(Q)) -> exists(not(Q))
       and(P,exists(Q)) -> exists(and(P,Q))
       or(P,exists(Q)) -> exists(or(P,Q))
       and(exists(Q),P) -> exists(and(Q,P))
       or(exists(Q),P) -> exists(or(Q,P))
       not(exists(Q)) -> forall(not(Q))
     Qed

******** Signature ********
 and : (form,form) -> form
 or : (form,form) -> form
 not : form -> form
 forall : (form -> form) -> form
 exists : (form -> form) -> form
******** Computation Rules ********
 (1)  and(P,forall(x.Q[x])) => forall(x.and(P,Q[x]))
 (2)  or(P,forall(x.Q[x])) => forall(x.or(P,Q[x]))
 (3)  and(forall(x.Q[x]),P) => forall(x.and(Q[x],P))
 (4)  or(forall(x.Q[x]),P) => forall(x.or(Q[x],P))
 (5)  not(forall(x.Q[x])) => exists(x.not(Q[x]))
 (6)  and(P,exists(x.Q[x])) => exists(x.and(P,Q[x]))
 (7)  or(P,exists(x.Q[x])) => exists(x.or(P,Q[x]))
 (8)  and(exists(x.Q[x]),P) => exists(x.and(Q[x],P))
 (9)  or(exists(x.Q[x]),P) => exists(x.or(Q[x],P))
 (10)  not(exists(x.Q[x])) => forall(x.not(Q[x]))

YES