implies changed to '==>'

Following a suggestion by C.G.Vedant, changed |implies| to |’==>’|

Author: norvig

logic.py

@@ -33,7 +33,7 @@
 
 from utils import (
     removeall, unique, first, every, argmax, probability, num_or_str,
-    isnumber, issequence, Symbol, Expr, expr, subexpressions, implies
+    isnumber, issequence, Symbol, Expr, expr, subexpressions
 )
 import agents
 
@@ -713,8 +713,8 @@ def translate_to_SAT(init, transition, goal, time):
                     action_sym[(s, action, t)] = Expr("Transition_{}".format(next(transition_counter)))
 
                     # Change the state from s to s_
-                    clauses.append(action_sym[s, action, t] |implies| state_sym[s, t])
-                    clauses.append(action_sym[s, action, t] |implies| state_sym[s_, t + 1])
+                    clauses.append(action_sym[s, action, t] |'==>'| state_sym[s, t])
+                    clauses.append(action_sym[s, action, t] |'==>'| state_sym[s_, t + 1])
 
         #Allow only one state at any time
         for t in range(time+1):

tests/test_logic.py

@@ -1,13 +1,13 @@
 import pytest
 from logic import *
-from utils import InfixOp, expr_handle_infix_ops, count, implies, equiv
+from utils import expr_handle_infix_ops, count
 
 
 def test_expr():
     assert repr(expr('P <=> Q(1)')) == '(P <=> Q(1))'
     assert repr(expr('P & Q | ~R(x, F(x))')) == '((P & Q) | ~R(x, F(x)))'
     assert (expr_handle_infix_ops('P & Q ==> R & ~S')
-            == "P & Q |InfixOp('==>', None)| R & ~S")
+            == "P & Q |'==>'| R & ~S")
 
 def test_extend():
     assert extend({x: 1}, y, 2) == {x: 1, y: 2}
@@ -17,7 +17,7 @@ def test_PropKB():
     assert count(kb.ask(expr) for expr in [A, C, D, E, Q]) is 0
     kb.tell(A & E)
     assert kb.ask(A) == kb.ask(E) == {}
-    kb.tell(E |implies| C)
+    kb.tell(E |'==>'| C)
     assert kb.ask(C) == {}
     kb.retract(E)
     assert kb.ask(E) is False
@@ -42,8 +42,8 @@ def test_KB_wumpus():
     B[2,1] = Symbol("B[2,1]")
 
     kb_wumpus.tell(~P[1,1])
-    kb_wumpus.tell(B[1,1] |equiv| ((P[1,2] | P[2,1])))
-    kb_wumpus.tell(B[2,1] |equiv| ((P[1,1] | P[2,2] | P[3,1])))
+    kb_wumpus.tell(B[1,1] |'<=>'| ((P[1,2] | P[2,1])))
+    kb_wumpus.tell(B[2,1] |'<=>'| ((P[1,1] | P[2,2] | P[3,1])))
     kb_wumpus.tell(~B[1,1])
     kb_wumpus.tell(B[2,1])
 

utils.py

@@ -373,10 +373,11 @@ def __floordiv__(self, rhs): return Expr('//', self, rhs)
     def __matmul__(self, rhs):   return Expr('@',  self, rhs)
 
     def __or__(self, rhs):
+        "Allow both P | Q, and P |'==>'| Q."
         if isinstance(rhs, Expression) :
             return Expr('|',  self, rhs)
         else:
-            return NotImplemented # So that InfixOp can handle it
+            return PartialExpr(rhs, self)
 
     # Reverse operator overloads
     def __radd__(self, lhs): return Expr('+',  lhs, self)
@@ -451,37 +452,34 @@ def arity(expression):
 
 # For operators that are not defined in Python, we allow new InfixOps:
 
-class InfixOp:
-    """Allow 'P |implies| Q, where P, Q are Exprs and implies is an InfixOp."""
-    def __init__(self, op, lhs=None): self.op, self.lhs = op, lhs
-    def __call__(self, lhs, rhs):     return Expr(self.op, lhs, rhs)
-    def __or__(self, rhs):            return Expr(self.op, self.lhs, rhs)
-    def __ror__(self, lhs):           return InfixOp(self.op, lhs)
-    def __repr__(self):               return "InfixOp('{}', {})".format(self.op, self.lhs)
-
-infix_ops = (implies, rimplies, equiv) = [InfixOp(o) for o in ['==>', '<==', '<=>']]
+class PartialExpr:
+    """Given 'P |'==>'| Q, first form PartialExpr('==>', P), then combine with Q."""
+    def __init__(self, op, lhs): self.op, self.lhs = op, lhs
+    def __or__(self, rhs):       return Expr(self.op, self.lhs, rhs)
+    def __repr__(self):          return "PartialExpr('{}', {})".format(self.op, self.lhs)
 
 def expr(x):
     """Shortcut to create an Expression. x is a str in which:
     - identifiers are automatically defined as Symbols.
-    - '==>' is treated as an infix |implies|, as are all infix_ops
+    - ==> is treated as an infix |'==>'|, as are <== and <=>.
     If x is already an Expression, it is returned unchanged. Example:
     >>> expr('P & Q ==> Q')
     ((P & Q) ==> Q)
     """
     if isinstance(x, str):
-        return eval(expr_handle_infix_ops(x),
-                    defaultkeydict(Symbol, InfixOp=InfixOp))
+        return eval(expr_handle_infix_ops(x), defaultkeydict(Symbol))
     else:
         return x
 
+infix_ops = '==> <== <=>'.split()
+
 def expr_handle_infix_ops(x):
-    """Given a str, return a new str with '==>' replaced by |InfixOp('==>')|, etc.
+    """Given a str, return a new str with ==> replaced by |'==>'|, etc.
     >>> expr_handle_infix_ops('P ==> Q')
-    "P |InfixOp('==>', None)| Q"
+    "P |'==>'| Q"
     """
     for op in infix_ops:
-        x = x.replace(op.op, '|' + str(op) + '|')
+        x = x.replace(op, '|' + repr(op) + '|')
     return x
 
 class defaultkeydict(collections.defaultdict):