Merge pull request #13 from jsiirola/singleton-feas-infeas

Convert Feasible/Infeasible to singletons

Author: jsiirola

pyomo/core/base/constraint.py

@@ -39,6 +39,7 @@
     RangedExpression,
 )
 from pyomo.core.expr.expr_common import _type_check_exception_arg
+from pyomo.core.expr.relational_expr import TrivialRelationalExpression
 from pyomo.core.expr.template_expr import templatize_constraint
 from pyomo.core.base.component import ActiveComponentData, ModelComponentFactory
 from pyomo.core.base.global_set import UnindexedComponent_index
@@ -67,6 +68,7 @@
     EqualityExpression,
     InequalityExpression,
     RangedExpression,
+    TrivialRelationalExpression,
 }
 _strict_relational_exprs = {True, (False, True), (True, False), (True, True)}
 _rule_returned_none_error = """Constraint '%s': rule returned None.
@@ -443,24 +445,9 @@ def set_value(self, expr):
         #
         # Ignore an 'empty' constraint
         #
-        elif expr.__class__ is type:
-            if expr is Constraint.Skip:
-                del self.parent_component()[self.index()]
-                return
-            elif expr is Constraint.Infeasible:
-                # Note that an inequality is sufficient to induce
-                # infeasibility and is simpler to relax (in the Big-M
-                # sense) than an equality.
-                self._expr = InequalityExpression((1, 0), False)
-                return
-            elif expr is Constraint.Feasible:
-                # Note that we do not want to provide a trivial equality
-                # constraint as that can confuse solvers like Ipopt into
-                # believing that the model has fewer degrees of freedom
-                # than it actually has.
-                self._expr = InequalityExpression((0, 0), False)
-                return
-            # else: fall through to the ValueError below
+        if expr is Constraint.Skip:
+            del self.parent_component()[self.index()]
+            return
 
         elif expr is None:
             raise ValueError(_rule_returned_none_error % (self.name,))
@@ -620,11 +607,8 @@ class Constraint(ActiveIndexedComponent):
 
     _ComponentDataClass = ConstraintData
 
-    class Infeasible(object):
-        pass
-
-    class Feasible(object):
-        pass
+    Infeasible = TrivialRelationalExpression('Infeasible', (1, 0))
+    Feasible = TrivialRelationalExpression('Feasible', (0, 0))
 
     NoConstraint = ActiveIndexedComponent.Skip
     Violated = Infeasible

pyomo/core/base/logical_constraint.py

@@ -112,17 +112,9 @@ def set_value(self, expr):
         #
         # Ignore an 'empty' constraint
         #
-        if expr.__class__ is type:
-            if expr is LogicalConstraint.Skip:
-                del self.parent_component()[self.index()]
-                return
-            elif expr is LogicalConstraint.Infeasible:
-                self._expr = BooleanConstant(False)
-                return
-            elif expr is LogicalConstraint.Feasible:
-                self._expr = BooleanConstant(True)
-                return
-            # else: fall through to the ValueError below
+        if expr is LogicalConstraint.Skip:
+            del self.parent_component()[self.index()]
+            return
 
         elif expr.__class__ in native_logical_types:
             self._expr = as_boolean(expr)
@@ -148,7 +140,7 @@ def set_value(self, expr):
                 if hasattr(expr, '_resolve_template'):
                     self._expr = expr
                     return
-            except AttributeError:
+            except (AttributeError, TypeError):
                 pass
 
         raise ValueError(
@@ -218,11 +210,8 @@ class LogicalConstraint(ActiveIndexedComponent):
 
     _ComponentDataClass = LogicalConstraintData
 
-    class Infeasible(object):
-        pass
-
-    class Feasible(object):
-        pass
+    Infeasible = BooleanConstant(False, 'Infeasible')
+    Feasible = BooleanConstant(True, 'Feasible')
 
     NoConstraint = ActiveIndexedComponent.Skip
     Violated = Infeasible

pyomo/core/expr/boolean_value.py

@@ -278,14 +278,32 @@ class BooleanConstant(BooleanValue):
         value           The initial value.
     """
 
-    __slots__ = ('value',)
-
-    def __init__(self, value):
-        if value not in native_logical_values:
-            raise TypeError(
-                'Not a valid BooleanValue. Unable to create a logical constant'
-            )
-        self.value = value
+    __slots__ = ('value', '_name')
+    singleton = {}
+
+    def __new__(cls, value, name=None):
+        if name is None:
+            name = value
+        if name not in cls.singleton:
+            if value not in native_logical_values:
+                raise TypeError(
+                    'Not a valid BooleanValue. Unable to create a logical constant'
+                )
+            cls.singleton[name] = super().__new__(cls)
+            cls.singleton[name].value = value
+            cls.singleton[name]._name = name
+        return cls.singleton[name]
+
+    def __deepcopy__(self, memo):
+        # Prevent deepcopy from duplicating this object
+        return self
+
+    def __reduce__(self):
+        return self.__class__, (self._name, self._args_)
+
+    def __init__(self, value, name=None):
+        # note that the meat of __init__ is called as part of __new__ above.
+        assert self.value == value
 
     def is_constant(self):
         return True
@@ -297,7 +315,7 @@ def is_potentially_variable(self):
         return False
 
     def __str__(self):
-        return str(self.value)
+        return str(self._name)
 
     def __nonzero__(self):
         return self.value

pyomo/core/expr/logical_expr.py

@@ -471,11 +471,14 @@ def _apply_operation(self, result):
         return all(result)
 
     def add(self, new_arg):
+        # FIXME: we should probably NOT perform this simplification
+        # here, and instead use a dispatcher-based expression generation
+        # system
         if new_arg.__class__ in native_logical_types:
-            if new_arg is False:
-                return BooleanConstant(False)
-            elif new_arg is True:
+            if new_arg:
                 return self
+            else:
+                return BooleanConstant(False)
         return _add_to_and_or_expression(self, new_arg)
 
 
@@ -498,11 +501,14 @@ def _apply_operation(self, result):
         return any(result)
 
     def add(self, new_arg):
+        # FIXME: we should probably NOT perform this simplification
+        # here, and instead use a dispatcher-based expression generation
+        # system
         if new_arg.__class__ in native_logical_types:
-            if new_arg is False:
-                return self
-            elif new_arg is True:
+            if new_arg:
                 return BooleanConstant(True)
+            else:
+                return self
         return _add_to_and_or_expression(self, new_arg)
 
 

pyomo/core/expr/relational_expr.py

@@ -307,6 +307,43 @@ def strict(self):
         return self._strict
 
 
+class TrivialRelationalExpression(InequalityExpression):
+    """A trivial relational expression
+
+    Note that an inequality is sufficient to induce infeasibility and is
+    simpler to relax (in the Big-M sense) than an equality.
+
+    Note that we do not want to provide a trivial equality constraint as
+    that can confuse solvers like Ipopt into believing that the model
+    has fewer degrees of freedom than it actually has.
+
+    """
+
+    __slots__ = ('_name',)
+    singleton = {}
+
+    def __new__(cls, name, args):
+        if name not in cls.singleton:
+            cls.singleton[name] = super().__new__(cls)
+            super().__init__(cls.singleton[name], args, False)
+            cls.singleton[name]._name = name
+        return cls.singleton[name]
+
+    def __init__(self, name, args):
+        # note that the meat of __init__ is called as part of __new__ above.
+        assert args == self.args
+
+    def __deepcopy__(self, memo):
+        # Prevent deepcopy from duplicating this object
+        return self
+
+    def __reduce__(self):
+        return self.__class__, (self._name, self._args_)
+
+    def _to_string(self, values, verbose, smap):
+        return self._name
+
+
 def inequality(lower=None, body=None, upper=None, strict=False):
     """
     A utility function that can be used to declare inequality and

pyomo/core/tests/unit/test_logical_constraint.py

@@ -117,8 +117,10 @@ def test_indexed_constructor(self):
             ],
         )
 
-        self.assertExpressionsStructurallyEqual(m.p[0].expr, BooleanConstant(True))
-        self.assertExpressionsStructurallyEqual(m.p[1].expr, BooleanConstant(False))
+        self.assertExpressionsStructurallyEqual(m.p[0].expr, LogicalConstraint.Feasible)
+        self.assertExpressionsStructurallyEqual(
+            m.p[1].expr, LogicalConstraint.Infeasible
+        )
         self.assertNotIn(2, m.p)
         with self.assertRaises(KeyError):
             m.p[2].expr
@@ -202,13 +204,13 @@ def test_pprint(self):
         m.p.pprint(ostream=OUT)
         self.assertEqual(
             """p : Size=6, Index={0, 1, 2, 3, 4, 5, 6}, Active=True
-    Key : Body    : Active
-      0 :    True :   True
-      1 :   False :   True
-      3 : x --> y :   True
-      4 :       x :   True
-      5 :    True :   True
-      6 :   False :   True
+    Key : Body       : Active
+      0 :   Feasible :   True
+      1 : Infeasible :   True
+      3 :    x --> y :   True
+      4 :          x :   True
+      5 :       True :   True
+      6 :      False :   True
 """,
             OUT.getvalue(),
         )
@@ -229,8 +231,10 @@ def p_rule(m, i):
 
         m.p = LogicalConstraint(NonNegativeIntegers, rule=p_rule)
 
-        self.assertExpressionsStructurallyEqual(m.p[0].expr, BooleanConstant(True))
-        self.assertExpressionsStructurallyEqual(m.p[1].expr, BooleanConstant(False))
+        self.assertExpressionsStructurallyEqual(m.p[0].expr, LogicalConstraint.Feasible)
+        self.assertExpressionsStructurallyEqual(
+            m.p[1].expr, LogicalConstraint.Infeasible
+        )
         self.assertNotIn(2, m.p)
         with self.assertRaises(KeyError):
             m.p[2].expr
@@ -287,23 +291,23 @@ def test_set_value(self):
         self.assertEqual(len(m.p), 0)
 
         m.p = LogicalConstraint.Feasible
-        self.assertExpressionsStructurallyEqual(m.p.expr, BooleanConstant(True))
+        self.assertExpressionsStructurallyEqual(m.p.expr, LogicalConstraint.Feasible)
 
         m.p = LogicalConstraint.Infeasible
-        self.assertExpressionsStructurallyEqual(m.p.expr, BooleanConstant(False))
+        self.assertExpressionsStructurallyEqual(m.p.expr, LogicalConstraint.Infeasible)
 
         with self.assertRaisesRegex(
-            ValueError, "Assigning improper value to LogicalConstraint 'p':"
+            ValueError, "Assigning improper value to LogicalConstraint 'p'."
         ):
             m.p = LogicalConstraint
 
         with self.assertRaisesRegex(
-            ValueError, "Assigning improper value to LogicalConstraint 'p':"
+            ValueError, "Assigning improper value to LogicalConstraint 'p'."
         ):
             m.p = {}
 
         with self.assertRaisesRegex(
-            ValueError, "Assigning improper value to LogicalConstraint 'p':"
+            ValueError, "Assigning improper value to LogicalConstraint 'p'."
         ):
             m.p = Param(mutable=True) + 1
 

pyomo/gdp/disjunct.py

@@ -588,9 +588,11 @@ def set_value(self, expr):
                         continue
                 except AttributeError:
                     pass
-                if _tmp_e in (Constraint.Feasible, Constraint.Infeasible):
-                    expressions.append(_tmp_e)
-                    continue
+                # Note: Constraint.(In)Feasible is now a full relational
+                # expression, so we don't need to check for it.
+                # LogicalConstraint.(In)Feasible is a BooleanConstant,
+                # so is not an expression and needs to be explicitly
+                # checked for.
                 if _tmp_e in (LogicalConstraint.Feasible, LogicalConstraint.Infeasible):
                     propositions.append(_tmp_e)
                     continue