atom : type.

p : atom.
q : atom.
r : atom.

prop : type.

atomic	: atom -> prop.
and	: prop -> prop -> prop.
or	: prop -> prop -> prop.
implies	: prop -> prop -> prop.
f	: prop.
t	: prop.

atomlist : type.

anil	: atomlist.
acons	: atom -> atomlist -> atomlist.

proplist : type.

pnil	: proplist.
pcons	: prop -> proplist -> proplist.


amember : atom -> atomlist -> type.
%mode amember +X +Y.

amember/hit	: amember X (acons X _).

amember/miss	: amember X (acons _ L)
		   <- amember X L.

%terminates X (amember _ X).
%worlds () (amember _ _).
%% %covers amember +X +Y.


pappend : proplist -> proplist -> proplist -> type.
%mode pappend +X +Y -Z.

pappend/pnil	: pappend pnil L L.

pappend/pcons	: pappend (pcons X L1) L2 (pcons X L3)
		   <- pappend L1 L2 L3.

%worlds () (pappend _ _ _).
%total X (pappend X _ _).


seqR	: atomlist -> proplist -> prop -> type.
%mode seqR +X +Y +Z.

seqL	: atomlist -> proplist -> proplist -> prop -> type.
%mode seqL +W +X +Y +Z.

choose	: atomlist -> proplist -> prop -> type.
%mode choose +X +Y +Z.

chooseR : atomlist -> proplist -> prop -> type.
%mode chooseR +X +Y +Z.

chooseL	: atomlist -> proplist -> proplist -> prop -> type.
%mode chooseL +W +X +Y +Z.

seqR/atomic	: seqR PL HL (atomic P)
		   <- seqL PL pnil HL (atomic P).

seqR/and	: seqR PL HL (and A B)
		   <- seqR PL HL A
		   <- seqR PL HL B.

seqR/or		: seqR PL HL (or A B)
		   <- seqL PL pnil HL (or A B).

seqR/implies	: seqR PL HL (implies A B)
		   <- seqR PL (pcons A HL) B.

seqR/t		: seqR PL HL t.

seqR/f		: seqR PL HL f
		   <- seqL PL pnil HL f.

seqL/atomic	: seqL PL SL (pcons (atomic P) HL) C
		   <- seqL (acons P PL) SL HL C.

seqL/and	: seqL PL SL (pcons (and A B) HL) C
		   <- seqL PL SL (pcons A (pcons B HL)) C.

seqL/or		: seqL PL SL (pcons (or A B) HL) C
		   <- seqL PL SL (pcons A HL) C
		   <- seqL PL SL (pcons B HL) C.

seqL/t		: seqL PL SL (pcons t HL) C
		   <- seqL PL SL HL C.

seqL/f		: seqL PL SL (pcons f HL) C.

seqL/impatom	: seqL PL SL (pcons (implies (atomic P) B) HL) C
		   <- seqL PL (pcons (implies (atomic P) B) SL) HL C.

seqL/impand	: seqL PL SL (pcons (implies (and D E) B) HL) C
		   <- seqL PL SL (pcons (implies D (implies E B)) HL) C.

seqL/impor	: seqL PL SL (pcons (implies (or D E) B) HL) C
		   <- seqL PL SL (pcons (implies D B) (pcons (implies E B) HL)) C.

seqL/impimp	: seqL PL SL (pcons (implies (implies D E) B) HL) C
		   <- seqL PL (pcons (implies (implies D E) B) SL) HL C.

seqL/impt	: seqL PL SL (pcons (implies t B) HL) C
		   <- seqL PL SL (pcons B HL) C.

seqL/impf	: seqL PL SL (pcons (implies f B) HL) C
		   <- seqL PL SL HL C.

seqL/pnil	: seqL PL SL pnil C
		   <- choose PL SL C.

choose/right	: choose PL SL C
		   <- chooseR PL SL C.

choose/left	: choose PL SL C
		   <- chooseL PL SL pnil C.


chooseR/or1	: chooseR PL SL (or A B)
		   <- seqR PL SL A.

chooseR/or2	: chooseR PL SL (or A B)
		   <- seqR PL SL B.

chooseR/atomic	: chooseR PL SL (atomic P)
		   <- amember P PL.

chooseL/impatom	: chooseL PL (pcons (implies (atomic P) B) SL) RSL C
		   <- amember P PL
		   <- pappend SL RSL NSL
		   <- seqL PL NSL (pcons B pnil) C.

chooseL/impimp	: chooseL PL (pcons (implies (implies D E) B) SL) RSL C
		   <- pappend SL RSL NSL
		   <- seqR PL (pcons (implies E B) (pcons D NSL)) E
		   <- seqL PL NSL (pcons B pnil) C.

chooseL/skip	: chooseL PL (pcons A SL) RSL C
		   <- chooseL PL SL (pcons A RSL) C.

prove : prop -> type.
%mode prove +X.

prove/drive	: prove A
		   <- seqR anil pnil A.