Add support for negated interval and negated explicit true/false

Author: ColtonPayne

pyreason/scripts/facts/fact.py

@@ -35,13 +35,15 @@ def __init__(self, fact_text: str, name: str = None, start_time: int = 0, end_ti
             - `'viewed(Zach):[0.5,0.8]'` - interval bound
             - `'connected(Alice,Bob)'` - edge fact
             - `'connected(Alice,Bob):[0.7,0.9]'` - edge fact with interval
+            - `'~pred(node):[0.2,0.8]'` - negation with explicit bound
+            NOTE: Negating an explicit bound will round the upper and lower bounds to 10 decimal places before taking the negation
+            This is needed to avoid floating point precision errors.
 
             **Invalid examples:**
             - `'123pred(node)'` - predicate starts with digit
             - `'pred@name(node)'` - invalid characters in predicate
             - `'pred(node1,node2,node3)'` - more than 2 components
             - `'pred(node):[1.5,2.0]'` - values out of range [0,1]
-            - `'~pred(node):[0.2,0.8]'` - negation with explicit bound
 
         :type fact_text: str
         :param name: The name of the fact. This will appear in the trace so that you know when it was applied

pyreason/scripts/utils/fact_parser.py

@@ -20,17 +20,24 @@ def parse_fact(fact_text):
         raise ValueError("Double negation is not allowed")
 
     # Separate into predicate-component and bound. If there is no bound it means it's true
+    negate_interval = False
     if ':' in f:
         parts = f.split(':')
         if len(parts) != 2:
             raise ValueError("Invalid fact format: expected at most one colon separator")
         pred_comp, bound = parts
 
-        # Check for negation with explicit bound (ambiguous)
+        # Check for negation with explicit bound 
         if pred_comp.startswith('~'):
-            raise ValueError("Cannot use negation (~) with explicit bound")
+            pred_comp = pred_comp[1:]
+            if bound.lower() == 'true':
+                bound = 'False'
+            elif bound.lower() == 'false':
+                bound = 'True'
+            else:
+                negate_interval = True
     else:
-        pred_comp = f
+        pred_comp = f   
         if pred_comp.startswith('~'):
             bound = 'False'
             pred_comp = pred_comp[1:]
@@ -109,10 +116,9 @@ def parse_fact(fact_text):
         fact_type = 'node'
 
     # Check if bound is a boolean or a list of floats
-    bound_lower = bound.lower()
-    if bound_lower == 'true':
+    if bound.lower() == 'true':
         bound = interval.closed(1, 1)
-    elif bound_lower == 'false':
+    elif bound.lower() == 'false':
         bound = interval.closed(0, 0)
     else:
         # Validate interval format
@@ -137,7 +143,6 @@ def parse_fact(fact_text):
             raise ValueError(f"Invalid interval values: {e}")
 
         lower, upper = bound_values
-
         # Validate bounds are in valid range [0, 1]
         if lower < 0 or lower > 1:
             raise ValueError(f"Interval lower bound {lower} is out of valid range [0, 1]")
@@ -148,6 +153,11 @@ def parse_fact(fact_text):
         if lower > upper:
             raise ValueError(f"Interval lower bound {lower} cannot be greater than upper bound {upper}")
 
-        bound = interval.closed(*bound_values)
+        # We calculate ~[l,u] = [1-u, 1-l]
+        # Round to eliminate floating point precision errors (e.g., 1 - 0.8 = 0.19999999...)
+        if negate_interval:
+            lower, upper = round(1 - upper, 10), round(1 - lower, 10)
+
+        bound = interval.closed(lower, upper)
 
     return pred, component, bound, fact_type

tests/unit/dont_disable_jit/test_fact_parser.py

@@ -3,7 +3,7 @@
 import pyreason.scripts.numba_wrapper.numba_types.interval_type as interval
 
 
-# Tests in this class were generated with Claude Sonnet 4.5.
+# Tests in this class were partially generated with Claude Sonnet 4.5.
 class TestValidFactParsing:
     """Test cases for valid fact inputs that should parse successfully."""
 
@@ -112,8 +112,26 @@ def test_interval_with_ones(self):
         assert pred == "pred"
         assert bound.lower == 1.0 and bound.upper == 1.0
 
+    def test_negation_with_interval_bound(self):
+        """Test that negation with interval bound."""
+        pred, component, bound, fact_type = parse_fact("~pred(node):[0.5,0.8]")
+        assert pred == "pred"
+        assert bound.lower == 0.2 and bound.upper == 0.5
 
-# Tests in this class were generated with Claude Sonnet 4.5.
+    def test_negation_with_explicit_bound_true(self):
+        """Test that negation with an explicit bound true."""
+        pred, component, bound, fact_type = parse_fact("~pred(node):True")
+        assert pred == "pred"
+        assert bound.lower == 0.0 and bound.upper == 0.0
+
+    def test_negation_with_explicit_bound_false(self):
+        """Test that negation with an explicit bound false."""
+        pred, component, bound, fact_type = parse_fact("~pred(node):False")
+        assert pred == "pred"
+        assert bound.lower == 1.0 and bound.upper == 1.0
+
+
+# Tests in this class were partially generated with Claude Sonnet 4.5.
 class TestInvalidFactParsing:
     """Test cases for invalid fact inputs that should raise validation errors."""
 
@@ -193,7 +211,7 @@ def test_missing_opening_bracket(self):
             parse_fact("pred(node):0.5,0.8]")
 
     def test_interval_lower_greater_than_upper(self):
-        """Test that interval with lower > upper raises an error or warning."""
+        """Test that interval with lower > upper raises an error."""
         with pytest.raises(ValueError):
             parse_fact("pred(node):[0.9,0.1]")
 
@@ -207,6 +225,11 @@ def test_interval_out_of_range_greater_than_one(self):
         with pytest.raises(ValueError):
             parse_fact("pred(node):[0.5,1.5]")
 
+    def test_interval_out_of_range_greater_than_one_with_negation(self):
+        """Test that interval values > 1 for a negated predicate raises an error."""
+        with pytest.raises(ValueError):
+            parse_fact("~pred(node):[0.5,1.5]")
+
     def test_empty_component_in_edge(self):
         """Test that empty component in edge fact raises an error."""
         with pytest.raises(ValueError):
@@ -227,15 +250,15 @@ def test_too_many_components_in_edge(self):
         with pytest.raises(ValueError):
             parse_fact("pred(node1,node2,node3)")
 
-    def test_negation_with_explicit_bound(self):
-        """Test that negation with explicit bound raises an error (ambiguous)."""
+    def test_negation_with_invalid_bound(self):
+        """Test that negation with invalid bound raises an error."""
         with pytest.raises(ValueError):
-            parse_fact("~pred(node):True")
+            parse_fact("~pred(node):Undefined")
 
-    def test_negation_with_interval_bound(self):
-        """Test that negation with interval bound raises an error (ambiguous)."""
+    def test_negation_with_invalid_interval_bound(self):
+        """Test that negation with invalid bound raises an error."""
         with pytest.raises(ValueError):
-            parse_fact("~pred(node):[0.5,0.8]")
+            parse_fact("~pred(node):[ham, sandwitch]")
 
     def test_double_negation(self):
         """Test that double negation raises an error."""