Merge pull request #137 from lab-v2/add-circumscription-2

Add closed_world predicates

Author: ColtonPayne

examples/closed_world_pred_ex.py

@@ -0,0 +1,57 @@
+import pyreason as pr
+import networkx as nx
+from pprint import pprint
+
+pr.reset()
+pr.reset_rules()
+
+g = nx.DiGraph()
+
+g.add_nodes_from(['cb_1', 'cb_2', 'l1', 'l2'])
+g.add_edge('cb_1', 'cb_2', stepFrom =1)
+g.add_edge('cb_1',  'l1', hasLabel = 1)
+g.add_edge('cb_2',  'l2', hasLabel = 1)
+#g.add_edge('l1','l2', cond=1) # Adding this edge will satisfy hackerControl(cb)
+
+pr.settings.verbose = True
+pr.settings.atom_trace = True
+pr.settings.inconsistency_check = True
+
+pr.load_graph(g)
+
+# hackerControl is a closed-world pred, meaning that it will be grounded as [0,0] if its bounds are [0,1] (or if it is not in the interpretation dict)
+pr.add_closed_world_predicate('hackerControl')
+
+# Initial fact instantiation
+pr.add_fact(pr.Fact('stepFrom(cb_1, cb_2)', 'step_from_fact', 0, 1))
+pr.add_fact(pr.Fact('hackerControl(cb_1)', 'hacker_control_initial_fact', 0, 0))
+
+# Future(Y) will fire for cb_2
+pr.add_rule(pr.Rule('future(Y) <-1 stepFrom(X,Y), hackerControl(X)'))
+
+#This rule will not fire for cb_2, as cond(cb_1, cb_2) is not grounded
+pr.add_rule(pr.Rule('hackerControl(Y) <-1 hackerControl(X), hasLabel(X,L1), hasLabel(Y,L2), cond(L1, L2), stepFrom(X,Y)', 'hacker-control-rule'))
+
+# At timestep 1, hackerControl(cb_1) and hackerControl(cb_2) have no associated bounds, so they are treated as [0,1].
+# Because hackerControl is minimized, its bounds are gounded as [0,0].  Future(cb_2) has bounds [1,1], so inconsistent(cb_2) fires.
+pr.add_rule(pr.Rule('inconsistent(Y) <- future(Y), ~hackerControl(Y), ~hackerControl(X)', 'inconsistent_rule'))
+
+
+interpretation = pr.reason(timesteps=2)
+interp_dict = interpretation.get_dict()
+
+pprint(interp_dict)
+
+# Filter and sort nodes based on hackerControl
+dataframes = pr.filter_and_sort_nodes(interpretation, ['hackerControl'])
+for t, df in enumerate(dataframes):
+    print(f'TIMESTEP - {t}')
+    print(df)
+    print()
+
+# Filter and sort edges based on inconsistent
+edge_dataframes = pr.filter_and_sort_nodes(interpretation, ['inconsistent'])
+for t, df in enumerate(edge_dataframes):
+    print(f'TIMESTEP - {t} (inconsistent nodes)')
+    print(df)
+    print()

pyreason/pyreason.py

@@ -466,6 +466,7 @@ def fp_version(self, value: bool) -> None:
 __ipl: Optional[numba.typed.List] = None
 __specific_node_labels: Optional[numba.typed.List] = None
 __specific_edge_labels: Optional[numba.typed.List] = None
+__closed_world_predicates = set()
 
 __non_fluent_graph_facts_node: Optional[numba.typed.List] = None
 __non_fluent_graph_facts_edge: Optional[numba.typed.List] = None
@@ -486,12 +487,13 @@ def reset():
     """Resets certain variables to None to be able to do pr.reason() multiple times in a program
     without memory blowing up
     """
-    global __node_facts, __edge_facts, __graph, __facts_name_set
+    global __node_facts, __edge_facts, __graph, __facts_name_set, __closed_world_predicates
 
     # Facts
     __node_facts = None
     __edge_facts = None
     __facts_name_set.clear()
+    __closed_world_predicates = set()
     if __program is not None:
         __program.reset_facts()
 
@@ -1085,6 +1087,17 @@ def _parse_and_validate_fact_params(idx, name_raw, start_time_raw, end_time_raw,
     return name, start_time, end_time, static
 
 
+def add_closed_world_predicate(predicate_name: str) -> None:
+    """Register a predicate as closed_world (circumscription). For any node/edge where
+    a closed_world predicate has bounds [0,1] (unknown), it will be treated as [0,0] (false)
+    during rule satisfaction checks.
+
+    :param predicate_name: The name of the predicate to minimize
+    :return: None
+    """
+    __closed_world_predicates.add(predicate_name)
+
+
 def add_fact(pyreason_fact: Fact) -> None:
     """Add a PyReason fact to the program.
 
@@ -1510,6 +1523,12 @@ def _reason(timesteps, convergence_threshold, convergence_bound_threshold, queri
     __program.specific_node_labels = __specific_node_labels
     __program.specific_edge_labels = __specific_edge_labels
 
+    # Convert closed_world predicates to numba-compatible list of label types
+    closed_world_preds_numba = numba.typed.List.empty_list(label.label_type)
+    for pred_name in __closed_world_predicates:
+        closed_world_preds_numba.append(label.Label(pred_name))
+    __program.closed_world_predicates = closed_world_preds_numba
+
     # Run Program and get final interpretation
     interpretation = __program.reason(timesteps, convergence_threshold, convergence_bound_threshold, settings.verbose)