Cake problem works now. On to debugging shopping problem );

aimacode · carwyn987 · Sep 25, 2025 · Sep 27, 2025 · Sep 27, 2025 · Sep 27, 2025
commit 5234d7b90e4aff8c690aecc7a55b2db17f233069
diff --git a/Screenshot from 2025-09-28 11-02-00.png b/Screenshot from 2025-09-28 11-02-00.png
diff --git a/Screenshot from 2025-09-29 11-24-54.png b/Screenshot from 2025-09-29 11-24-54.png
diff --git a/cake_example_graph.png b/cake_example_graph.png
diff --git a/cake_problem_graph2.png b/cake_problem_graph2.png
diff --git a/cake_problem_graph3.png b/cake_problem_graph3.png
diff --git a/planning.py b/planning.py
@@ -877,6 +877,7 @@ def __init__(self, kb, is_first_layer=False):
 
         self.is_first_layer = is_first_layer
         self.next_state_mutexes = []
+        self.state_mutexes = []
 
     def __call__(self, actions, objects):
         self.build(actions, objects)
@@ -916,6 +917,7 @@ def find_mutex(self):
         "Therefore, we're computing it for the current state and current (state+1) action layer"
 
         #breakpoint()
+        self.state_mutexes = self.mutex # save state mutexes
         self.mutex = [] # clear out effects from state mutex prior computation
 
         # Inconsistent effects - one action adds a literal that another deletes
@@ -930,11 +932,15 @@ def find_mutex(self):
                             if {a, b} not in self.mutex:
                                 self.mutex.append({a, b})
 
-        # Interference will be calculated with the last step
+        # Interference will be calculated with the last step ???
         # Interference - One action deletes a precondition or effect of another
- pos_csl, neg_csl = self.separate(self.current_state_links)
+
 
         # Competing needs - preconditions of two actions are mutex at previous proposition layer
+        """
+        pos_csl, neg_csl = self.separate(self.current_state_links)
+        # Why are we looking at syntactic components (negation)???
+        breakpoint()
         for pos_precond in pos_csl:
             for neg_precond in neg_csl:
                 new_neg_precond = Expr(neg_precond.op[3:], *neg_precond.args)
@@ -943,9 +949,36 @@ def find_mutex(self):
                         for b in self.current_state_links[neg_precond]:
                             if {a, b} not in self.mutex:
                                 self.mutex.append({a, b})
-
-        # Only consider actual actions (not propositions)
         """
+
+        # Competing Needs
+        # self.current_state_links = map from current state vars -> actions applicable
+        # self.current_action_links = map from current actions -> starting states
+
+        # Implement here: Iterate over all valid pairs of actions, and if the states they come from are mutex (use self.state_mutexes), add a mutex pair to self.mutex
+        # Competing Needs - two actions are mutex if any of their preconditions are mutex at the previous state level
+        for a1, a2 in itertools.combinations(self.current_action_links.keys(), 2):
+            preconds_a1 = self.current_action_links[a1] # states
+            preconds_a2 = self.current_action_links[a2]
+
+            #if len(preconds_a1) > 1 or len(preconds_a2) > 1:
+            #    print("An action has multiple preconditions (state)? Is the following logic implemented correctly? I think so")
+
+            # check all pairs of preconditions
+            for p in preconds_a1:
+                for q in preconds_a2:
+                    if {p, q} in self.state_mutexes:
+                        mutex_pair = {a1, a2}
+                        if mutex_pair not in self.mutex:
+                            self.mutex.append(mutex_pair)
+                        # no need to keep checking once we've marked them
+                        break
+                else:
+                    continue
+                break                      
+
+        """
+        # Only consider actual actions (not propositions)
         action_keys = [a for a in self.next_action_links.keys() if not a.op.startswith("P")]
 
         if self.is_first_layer:

diff --git a/submission1_test.py b/submission1_test.py
@@ -23,15 +23,15 @@ def verify_solution(P):
         P.act(expr(act))
     assert P.goal_test() == True
 
-def ptest_air_cargo():
+def test_air_cargo():
     P = air_cargo()
     verify_solution(P)
 
 def test_spare_tire():
     P = spare_tire()
     verify_solution(P)
 
-def ptest_three_block_tower():
+def test_three_block_tower():
     P = three_block_tower()
     verify_solution(P)
 
@@ -80,7 +80,7 @@ def test_logistics_plan_valid(goal_state):
     "In(C1, D3) & In(C2, D3) & In(C3, D3)",
     "In(C1, D2) & In(C3, D3) & In(C2, D1)",
 ])
-def ptest_logistics_plan_no_plan(goal_state):
+def test_logistics_plan_no_plan(goal_state):
     """These are known to have no valid plan."""
     init = "In(C1, R1) & In(C2, D1) & In(C3, D2) & In(R1, D1) & Holding(R1)"
     P = logisticsPlanCustom(init, goal_state)