Large changes to negation code

1. Change in naming

2. Multiple guesses at once

3. Distinction between delaying and committing to a condition

Note: This commit does not change the rules yet

Author: sei-eschwartz

share/prolog/oorules/guess.pl

@@ -1667,38 +1667,71 @@
     negation_helper(not(factNOTRealDestructor(RealDestructor))),
     true.
 
-tryNegation(G) :-
-    loginfoln('Guessing ~Q.', negation_commit(G)),
-    try_assert(negation_commit(G)).
+tryDelay((G,P,Commit)) :-
+    try_retract(delay_queue(G, P, Commit)),
 
-tryNOTNegation(G) :-
-    loginfoln('Guessing ~Q.', negation_fail(G)),
-    try_assert(negation_fail(G)).
+    % Do nothing if we've already committed one way or the other
+    %% (not(G) -> true;
+    %%  delay_goal(G, _) -> true;
+    %%  delay_fail(G) -> true;
+
+     loginfoln('Guessing ~Q.', delay_goal(G, Commit)),
+     try_assert(delay_goal(G, Commit)).
+
+tryNOTDelay((G,P)) :-
+    loginfoln('tryNOTDelay'),
+    try_retract(delay_queue(G, P, Commit)),
+
+    % Do nothing if we've already committed one way or the other
+    %% (not(G) -> true;
+    %%  delay_goal(G, _) -> true;
+    %%  delay_fail(G) -> true;
+
+     loginfoln('Guessing ~Q.', delay_fail(G)),
+     try_assert(delay_fail(G)).
+
+tryOrNOTDelay((G, P)) :-
+    % XXX Optimization for not(G)...
+
+    try_retract(delay_queue(G, P)),
+
+    % Do nothing if we've already committed one way or the other
+    delay_goal(G, _) -> true;
+    delay_fail(G) -> true;
 
-tryOrNOTNegation(G) :-
-    %likelyDeletingDestructor(Method, _RealDestructor),
-    doNotGuessHelper(negation_commit(G),
-                     negation_fail(G)),
     (
-        tryNegation(G);
-        tryNOTNegation(G);
-        logwarnln('Something is wrong upstream: ~Q.', negation(Method)),
+        tryDelay(G);
+        tryNOTDelay(G);
+        logwarnln('Something is wrong upstream: ~Q.', delay(Method)),
         fail
     ).
 
-guessNegation(Out) :-
-    reportFirstSeen('guessNegation'),
+guessDelay(Out) :-
+    reportFirstSeen('guessDelay'),
+
+    % Remove each false or already committed to delay
+    forall(delay_queue(G, P, Commit),
+           ((not(G);
+            delay_goal(G, _);
+            delay_fail(G))
+           -> (logdebugln('Removing outdated delay goal ~Q', [G]),
+               retract(delay_queue(G, P, Commit)))
+           ; true)),
+
+    !,
 
-    %setof(P, negation_queue(_, P), Pset),
-    %max_list(Pset, Pmax),
+    setof(P, delay_queue(_, P, _), Pset),
+    max_list(Pset, Pmax),
 
     % Sorting the queue takes a while.  We should really use a priority queue...
     % but this hack works ok for now.
-    member(Pmax, [0, -10, _]),
+    %member(Pmax, [0, -10, _]),
 
-    retract(negation_queue(G, Pmax)),
-    !,
-    (G, not(negation_commit(G)), not(negation_fail(G)) -> Out = tryOrNOTNegation(G); guessNegation(Out)).
+    setof((G, Pmax, Commit),
+          delay_queue(G, Pmax, Commit),
+          Gset),
+
+    Out = tryBinarySearch(tryDelay, tryNOTDelay, Gset).
 
 %% Local Variables:
 %% mode: prolog

share/prolog/oorules/insanity.pl

@@ -332,7 +332,7 @@
 % that way.
 :- table insanityNegation/1 as incremental.
 insanityNegation(Out) :-
-    negation_commit(G),
+    delay_goal(G, true),
 
     not(G),
 

share/prolog/oorules/util.pl

@@ -5,36 +5,54 @@
 
 :- use_module(library(lists), [append/3, nth1/4, list_to_set/2]).
 
-:- dynamic negation_queue/2.
-:- dynamic negation_fail/1.
-:- dynamic negation_commit/1 as incremental.
+% Delayed and committed negations.  The following code is used to indicate a delayed check,
+% which is how it sounds.  A delayed check may optionally be committed to, which ensures that
+% the check can not become false in the future.
 
-negation_helper(G) :- negation_helper(G, 0).
+:- dynamic delay_queue/3.
 
-negation_helper(G, _) :-
-    var(G) -> throw_with_backtrace(user_error(negation_helper)).
+:- dynamic delay_fail/1.
 
-% We've already committed to G
-negation_helper(G, _) :-
-    negation_commit(G),
-    logtraceln('Already committed ~Q', G),
+%:- dynamic delay_commit/1 as incremental.
+
+% delayed_goal(Goal, Commit).  Commit=true iff the goal should never become false in the
+% future.
+:- dynamic delay_goal/2 as incremental.
+
+%delay_helper(G) :- delay_helper(G, 0, false).
+
+delay(G) :- delay_helper(G, 0, false).
+
+delay_and_commit(G) :- delay_and_commit(G, 0).
+
+delay_and_commit(G, P) :- delay_helper(G, P, true).
+
+delay_helper(G, _, _) :-
+    var(G) -> throw_with_backtrace(user_error(delay_helper)).
+
+% We've already delayed for G
+delay_helper(G, _, _) :-
+    delay_goal(G, _),
+    logtraceln('Already delayed ~Q', G),
     !.
 
 % G results in a sanity failure
-negation_helper(G, _) :-
-    negation_fail(G), !, fail.
+delay_helper(G, _, _) :-
+    delay_fail(G), !, fail.
 
 % G isn't true right now.
-negation_helper(G, _) :-
+delay_helper(G, _, _) :-
     not(G), !, fail.
 
 % Queue G and fail.
-negation_helper(G, P) :-
+delay_helper(G, P, Commit) :-
     !,
-    (negation_queue(G, OldP), P >= OldP)
+    (delay_queue(G, OldP, Commit), P >= OldP)
     % There is a better or same priority queued element
     -> fail
-    ; logdebugln('I am queueing negation ~Q', G), assert(negation_queue(G, P)), logdebugln('done'), fail.
+    ; logdebugln('I am queueing delay ~Q', G),
+      assert(delay_queue(G, P, Commit)),
+      fail.
 
 
 sort_tuple((A,B), (C,D)) :-