These are for reference; they are not required studying for the exam.

--------- Situation Calculus Sentence converted to clausal form;
          at end, it's shown that not all resulting clauses can be
          converted to clausal form.

all A,S,O,X,Y 
   (poss(A,S) -->
      (at(O,Y,result(A,S)) <--> 
          ((A = go(X,Y) ^ (O = agent v holding(O,S))) v
           (at(O,Y,S) ^ ~(exist Z ~(Y=Z) ^ A=go(Y,Z) ^
                           (O = agent v holding(O,S)))))))

1) Replace A <--> B by (A --> B) ^ (B --> A). Replace A --> B by ~A or B
all A,S,O,X,Y 
   (~poss(A,S) or
      (at(O,Y,result(A,S)) --> 
          ((A = go(X,Y) ^ (O = agent v holding(O,S))) v
           (at(O,Y,S) ^ ~(exist Z ~(Y=Z) ^ A=go(Y,Z) ^
                           (O = agent v holding(O,S)))))) and
       (at(O,Y,result(A,S)) <-- 
          ((A = go(X,Y) ^ (O = agent v holding(O,S))) v
           (at(O,Y,S) ^ ~(exist Z ~(Y=Z) ^ A=go(Y,Z) ^
                           (O = agent v holding(O,S)))))))
all A,S,O,X,Y 
   (~poss(A,S) or
      (~at(O,Y,result(A,S)) or 
          ((A = go(X,Y) ^ (O = agent v holding(O,S))) v
           (at(O,Y,S) ^ ~(exist Z ~(Y=Z) ^ A=go(Y,Z) ^
                           (O = agent v holding(O,S)))))) and
       (at(O,Y,result(A,S)) or 
          ~((A = go(X,Y) ^ (O = agent v holding(O,S))) v
           (at(O,Y,S) ^ ~(exist Z ~(Y=Z) ^ A=go(Y,Z) ^
                           (O = agent v holding(O,S)))))))
2) Move ~ “inwards”
all A,S,O,X,Y 
   (~poss(A,S) or
      (~at(O,Y,result(A,S)) or 
          ((A = go(X,Y) ^ (O = agent v holding(O,S))) v
           (at(O,Y,S) ^ (all Z (Y=Z) v ~(A=go(Y,Z)) v
                           (~(O = agent) ^ ~holding(O,S)))))) and
       (at(O,Y,result(A,S)) or 
           ((~(A = go(X,Y)) v (~(O = agent) ^ ~holding(O,S))) ^
            (~at(O,Y,S) v  (exist Z ~(Y=Z) ^ A=go(Y,Z) ^
                           (O = agent v holding(O,S)))))))
3) Standardize variables
all A,S,O,X,Y 
   (~poss(A,S) or
      (~at(O,Y,result(A,S)) or 
          ((A = go(X,Y) ^ (O = agent v holding(O,S))) v
           (at(O,Y,S) ^ (all Z (Y=Z) v ~(A=go(Y,Z)) v
                           (~(O = agent) ^ ~holding(O,S)))))) and
       (at(O,Y,result(A,S)) or 
           ((~(A = go(X,Y)) v (~(O = agent) ^ ~holding(O,S))) ^
            (~at(O,Y,S) v  (exist B ~(Y=B) ^ A=go(Y,B) ^
                           (O = agent v holding(O,S)))))))
4) Skolemize
all A,S,O,X,Y 
   (~poss(A,S) or
      (~at(O,Y,result(A,S)) or 
          ((A = go(X,Y) ^ (O = agent v holding(O,S))) v
           (at(O,Y,S) ^ (all Z (Y=Z) v ~(A=go(Y,Z)) v
                           (~(O = agent) ^ ~holding(O,S)))))) and
       (at(O,Y,result(A,S)) or 
           ((~(A = go(X,Y)) v (~(O = agent) ^ ~holding(O,S))) ^
            (~at(O,Y,S) v  ( ~(Y=g1(A,S,O,X,Y)) ^ A=go(Y,g1(A,S,O,X,Y)) ^
                           (O = agent v holding(O,S)))))))
5) Drop universal quantifiers
(~poss(A,S) or
  (~at(O,Y,result(A,S)) or 
      ((A = go(X,Y) ^ (O = agent v holding(O,S))) v
       (at(O,Y,S) ^ ((Y=Z) v ~(A=go(Y,Z)) v
                       (~(O = agent) ^ ~holding(O,S)))))) and
   (at(O,Y,result(A,S)) or 
       ((~(A = go(X,Y)) v (~(O = agent) ^ ~holding(O,S))) ^
        (~at(O,Y,S) v  ( ~(Y=g1(A,S,O,X,Y)) ^ A=go(Y,g1(A,S,O,X,Y)) ^
                       (O = agent v holding(O,S)))))))
6) Distributive law
To make it easier, the following replacements were made
R1: poss(A,S) 
R2: at(O,Y,result(A,S))
R3: A = go(X,Y)
R4: O = agent
R5: holding(O,S)
R6: at(O,Y,S)
R7: A=go(Y,Z)
R8: Y=Z
R9: Y=g1(A,S,O,X,Y)
R10: A=go(Y,g1(A,S,O,X,Y))
(~R1 v
  (~R2 v 
      ((R3 ^ (R4 v R5)) v
       (R6 ^ (R8 v ~R7 v
                       (~(R4) ^ ~R5))))) ^
   (R2 v 
       ((~R3 v (~(R4) ^ ~R5)) ^
        (~R6 v  ( ~R9 ^ R10 ^
                       (R4 v R5))))))

~R1v~R2vR3vR6 ^ ~R1v~R2vR4vR5vR6 ^ ~R1v~R2vR3vR8v~R7v~R4 ^ 
~R1v~R2vR4vR5vR8v~R7v~R4 ^ ~R1v~R2vR3vR8v~R7v~R5 ^ 
~R1v~R2vR4vR5vR8v~R7v~R5 ^  

~R1vR2v~R3v~R4 ^ ~R1vR2v~R3v~R5 ^ ~R1vR2v~R6v~R9 ^ ~R1vR2v~R6vR10 ^ 
~R1vR2v~R6vR4vR5

7) Create separate clause for each conjunct
Note: deleted clauses with RA v ~ RA since tautology.
~R1 v ~R2 v R3 v R6
~R1 v R2 v ~R3 v ~R4
~R1 v R2 v ~R3 v ~R5
~R1 v R2 v ~R6 v ~R9
~R1 v R2 v ~R6 v R10
~R1 v R2 v R4 v R5 v ~R6
~R1 v ~R2 v R4 v R5 v R6
~R1 v ~R2 v R3 v ~R4 v ~R7 v R8 
~R1 v ~R2 v R3 v ~R5 v ~R7 v R8

~poss(A,S) v ~at(O,Y,result(A,S)) v A=go(X,Y) v at(O,Y,S)
~poss(A,S) v at(O,Y,result(A,S)) v ~A=go(X,Y) v ~O=agent
~poss(A,S) v at(O,Y,result(A,S)) v ~A=go(X,Y) v ~holding(O,S)
~poss(A,S) v at(O,Y,result(A,S)) v ~at(O,Y,S) v ~Y=g1(A,S,O,X,Y)
~poss(A,S) v at(O,Y,result(A,S)) v ~at(O,Y,S) v A=go(Y,g1(A,S,O,X,Y))
~poss(A,S) v at(O,Y,result(A,S)) v O=agent v holding(O,S) v ~at(O,Y,S)
~poss(A,S) v ~at(O,Y,result(A,S)) v O=agent v holding(O,S) v at(O,Y,S)
~poss(A,S) v ~at(O,Y,result(A,S)) v A=go(X,Y) v ~O=agent v ~A=go(Y,Z) v Y=Z 
~poss(A,S) v ~at(O,Y,result(A,S)) v 
    A=go(X,Y) v ~holding(O,S) v ~A=go(Y,Z) v Y=Z

8) Standardize apart so same variable doesn’t appear in 2 clauses
~poss(A1,S1) v ~at(O1,Y1,result(A1,S1)) v A1=go(X1,Y1) v at(O1,Y1,S1)
~poss(A2,S2) v at(O2,Y2,result(A2,S2)) v ~A2=go(X2,Y2) v ~O2=agent
~poss(A3,S3) v at(O3,Y3,result(A3,S3)) v ~A3=go(X3,Y3) v ~holding(O3,S3)
~poss(A4,S4) v at(O4,Y4,result(A4,S4)) v 
    ~at(O4,Y4,S4) v ~Y4=g1(A4,S4,O4,X4,Y4)
~poss(A5,S5) v at(O5,Y5,result(A5,S5)) v ~at(O5,Y5,S5) v 
   A5=go(Y5,g1(A5,S5,O5,X5,Y5))
~poss(A6,S6) v at(O6,Y6,result(A6,S6)) v O6=agent v holding(O6,S6) v 
   ~at(O6,Y6,S6)
~poss(A7,S7) v ~at(O7,Y7,result(A7,S7)) v O7=agent v holding(O7,S7) v 
   at(O7,Y7,S7)
~poss(A8,S8) v ~at(O8,Y8,result(A8,S8)) v A8=go(X8,Y8) v ~O8=agent v 
   ~A8=go(Y8,Z8) v Y8=Z8 
~poss(A9,S9) v ~at(O9,Y9,result(A9,S9)) v A9=go(X9,Y9) v ~holding(O9,S9) v 
   ~A=go(Y9,Z9) v Y9=Z9

9) Convert to Prolog

Can't convert several clauses, because clauses are not in Horn form
(exactly 1 positive literal). Also note that Prologs = operator
will fail for things such as soda=pop even though they could be equal
in first order logic. Prolog uses the unique name assumption.

~poss(A1,S1) v ~at(O1,Y1,result(A1,S1)) v A1=go(X1,Y1) v at(O1,Y1,S1)

at(O2,Y2,result(A2,S2)) :- poss(A2,S2),A2=go(X2,Y2),O2=agent
at(O3,Y3,result(A3,S3)) :- poss(A3,S3),A3=go(X3,Y3),holding(O3,S3)
at(O4,Y4,result(A4,S4)) :- poss(A4,S4),at(O4,Y4,S4),Y4=g1(A4,S4,O4,X4,Y4)
~poss(A5,S5) v at(O5,Y5,result(A5,S5)) v ~at(O5,Y5,S5) v 
   A5=go(Y5,g1(A5,S5,O5,X5,Y5))
~poss(A6,S6) v at(O6,Y6,result(A6,S6)) v O6=agent v holding(O6,S6) v 
   ~at(O6,Y6,S6)
~poss(A7,S7) v ~at(O7,Y7,result(A7,S7)) v O7=agent v holding(O7,S7) v 
   at(O7,Y7,S7)
~poss(A8,S8) v ~at(O8,Y8,result(A8,S8)) v A8=go(X8,Y8) v ~O8=agent v 
   ~A8=go(Y8,Z8) v Y8=Z8 
~poss(A9,S9) v ~at(O9,Y9,result(A9,S9)) v A9=go(X9,Y9) v ~holding(O9,S9) v 
   ~A=go(Y9,Z9) v Y9=Z9
------
=============
===================================
This is interesting; the clausal form reveals what the sentence
"really" means:

not (exists G (owns(mary,G) -> wontdate(mary,john))).

Get rid of implication:
  not (exists G (not owns(mary,G) or wontdate(mary,john))).
reduce scope of not :
  all G not (not owns(mary,G) or wontdate(mary,john)).
reduce scope of not :
  all G (owns(mary,G) & not wontdate(mary,john)).
result is 2 clauses:
  owns(mary,G).
  not wontdate(mary,john).

So, Mary owns everything!  
========================================
Just some more practice:

all X,Y ((r(X) or s(X)) --> (t(Y) and u(Y))).

1) Replace A --> B by ~A or B
all X,Y   ~(r(X) or s(X)) v (t(Y) and u(Y)).
2) Move ~ “inwards”
all X,Y   (~r(X) and ~s(X)) v (t(Y) and u(Y)).
3) Standardize variables
4) Skolemize
5) Drop universal quantifiers
(~r(X) and ~s(X)) v (t(Y) and u(Y)).
6) Distributive law
((~r(X) and ~s(X)) v t(Y)) and ((~r(X) and ~s(X)) v u(Y)).
(~r(X) v t(Y)) and (~s(X) v t(Y)) and (~r(X) v u(Y)) and (~s(X) v u(Y)).
7) Create separate clause for each conjunct
~r(X) v t(Y).
~s(X) v t(Y).
~r(X) v u(Y).
~s(X) v u(Y).
8) Standardize apart so same variable doesn’t appear in 2 clauses 
~r(X) v t(Y).
~s(W) v t(Z).
~r(A) v u(B).
~s(C) v u(D).
9) Convert to Prolog
t(Y) :- r(X).
t(Z) :- s(W).
u(B) :- r(A).
u(D) :- s(C).

ANSWER
t(Y) :- r(X).
t(Z) :- s(W).
u(B) :- r(A).
u(D) :- s(C).

=====
Just some more practice:
all X,Y (r(X) --> (t(Y) or u(Y))).

1) Replace A --> B by ~A or B
all X,Y   ~r(X) or t(Y) or u(Y).
2) Move ~ “inwards”
3) Standardize variables
4) Skolemize
5) Drop universal quantifiers
~r(X) or t(Y) or u(Y).
6) Distributive law
7) Create separate clause for each conjunct
~r(X) or t(Y) or u(Y).
8) Standardize apart so same variable doesn’t appear in 2 clauses 
9) Convert to Prolog
Can’t convert, because clauses are not in Horn form (exactly 1 positive literal).

ANSWER
~r(X) or t(Y) or u(Y).

=======
Just some more practice:
all X,Y (r(X)  --> (t(Y) and u(Y))).

1) Replace A --> B by ~A or B
all X,Y   ~r(X) or t(Y) and u(Y).
2) Move ~ “inwards”
3) Standardize variables
4) Skolemize
5) Drop universal quantifiers
~r(X) or t(Y) and u(Y).
6) Distributive law
(~r(X) or t(Y)) and (~r(X) or  u(Y)).
7) Create separate clause for each conjunct
~r(X) or t(Y).
~r(X) or u(Y).
8) Standardize apart so same variable doesn’t appear in 2 clauses 
~r(X) or t(Y).
~r(W) or u(Z).
9) Convert to Prolog
t(Y) :- r(X).
u(Z) :- r(W).

ANSWER
t(Y) :- r(X).
u(Z) :- r(W).