/* Precondition Axioms */
	poss(open(C),S):-
		is_container(C),
		isClosed(C,S).

	poss(close(C),S):-
		is_container(C),
		not(isClosed(C,S)).

	poss(fetch(X,Y),S):-
		is_container(Y),
		inside(X,Y,S),
		not isClosed(Y,S).

	poss(putAway(X,Y),S):-
		is_container(Y),
		have(X,S),
		not(isClosed(Y,S)).

	poss(loosen(X,Y),S):-
		nut(X),
		hub(Y),
		have(wrench,S),
		on(X,Y,S),
		tight(X,Y,S),
		on(Y,ground,S).

	poss(tighten(X,Y),S):-
		nut(X),
		hub(Y),
		have(wrench,S),
		on(X,Y,S),
		not tight(X,Y,S),
		on(Y,ground,S).

	poss(jackUp(Object),S):-
		have(jack,S),
		not lifted(Object,S),
		on(Object,ground,S).

	poss(jackDown(Object),S):-
		lifted(Object,S),
		not on(Object,ground,S).

	poss(remove(N,H),S):-
		nut(N),
		hub(H),
		lifted(H,S),
		on(N,H,S),
		fastened(H,S),
		have(wrench,S),
		not(tight(N,H,S)),

	poss(putOn(N,H),S):-
		nut(N),
		hub(H),
		lifted(H,S),
		not fastened(H,S),
		have(N,S),
		have(wrench,S),
		not on(N,H,S).

	poss(remove(W,H),S):-
		wheel(W),
		hub(H),
		lifted(H,S),
		not fastened(H,S),
		on(W,H,S).

	poss(putOn(W,H)):-
		wheel(W),
		hub(H),
		have(W,S),
		free(H,S),
		lifted(H,S),
		not fastened(H,S),
		not on(W,H,S).

		/* Successor State Axioms */

	inside(Object, Container, [putAway(Object,Container) | S]) :- is_container(Container).
	inside(Object, Container, [A | S]) :- inside( Object, Container, S ),
		not(A=fetch(Object,Container)).

inflated(W, [A | S]) :- wheel(W), inflated(W,S).

isClosed(C, [close(C) | S]):- is_container(C).
isClosed(C, [A|S]) :- isClosed(C, S), not A=open(C).

have(X, [fetch(X,Y) | S]) :- is_container(Y).
have(X, [remove(X,Y) | S]).

have(jack, [jackDown(Object)|S]).
have(jack, [A|S]) :- not (A=jackUp(X)), have(jack,S).
have(X, [A|S]) :- not (A=putAway(X,Y)), have(X,S).

tight(N,H, [tighten(N,H) | S]).
tight(N,H, [A | S]) :- tight(N,H,S), not(A=loosen(N,H)).

lifted(X, [jackUp(X) | S]).
lifted(X, [A|S]) :- lifted(X,S), not (A=jackDown(X)).

on(X,ground, [jackDown(X)|S]).
on(X, ground, [A|S]) :- on(X, ground, S), not A=jackUp(X).

on(X,Y, [putOn(X,Y) | S]).
on(X,Y, [A | S]) :- on(X,Y,S), not A=jackDown(X), not A=remove(X,Y).

fastened(H, [tighten(N, H) | S]) :- nut(N), hub(H).
fastened(H, [A|S]) :- nut(N), hub(H), not A=loosen(N, H), not A=remove(N,H), fastened(H,S).

free(H, [remove(W,H)|S]).
free(H, [A|S]) :- free(H,S), not A=putOn(W,H).

		/* Declarative  Heuristics */

useless(close(C), [A | S]) :- A=open(C).
useless(open(C), [A | S]) :- A=close(C).

useless(putOn(X, Y), [A | S]) :- A=remove(X,Y).
useless(remove(X,Y), [A | S]) :- A=putOn(X, Y).

useless(fetch(X,Y), [A|S]) :- A=putAway(X,Y).
useless(putAway(X,Y), [A|S]) :- A=fetch(X,Y).

useless(loosen(X,Y), [A | S]) :- A=tighten(X,Y).
useless(tighten(X,Y), [A|S]) :- A=loosen(X,Y).

useless(jackUp(X), [A|S]) :- A=jackDown(X).
useless(jackDown(X), [A|S]) :- A=jackUp(X).
    useless(jackUp(X), S) :- member(jackUp(X), S).
    useless(jackDown(X), S) :- member(jackDown(X), S).