Add forall tag to preconditions

.gitignore

@@ -17,3 +17,6 @@ dist/
 
 # Mypy specific
 .mypy_cache/
+
+# Vim
+*.swp

src/pddlsim/_asp.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Generator, MutableMapping, Sequence
+from collections.abc import Callable, Generator, MutableMapping, Sequence, Mapping
 from dataclasses import dataclass, field
 from enum import StrEnum
 from itertools import chain
@@ -15,6 +15,7 @@
     Condition,
     Domain,
     EqualityCondition,
+    ForallCondition,
     Identifier,
     NotCondition,
     Object,
@@ -454,6 +455,7 @@ def argument_to_asp(argument: Argument) -> ArgumentAST:
 
 
 def action_definition_asp_part(
+    problem: Problem,
     action_definition: ActionDefinition,
     variable_id_allocator: IDAllocator[Variable],
     object_id_allocator: IDAllocator[Object],
@@ -478,9 +480,52 @@ def action_definition_asp_part(
             ],
         )
 
-    # Specify the precondition over the parameters
+    # Preprocess precondition to replace Foralls with series of Ands
+    def _expand_substitute(
+        condition: Condition[Argument], substitutions: Mapping[Variable, Object]
+    ) -> Condition[Object]:
+        """Fold in to use global information for Forall..."""
+        match condition:
+            case AndCondition(subconditions):
+                return AndCondition(
+                    [
+                        _expand_substitute(subcondition, substitutions)
+                        for subcondition in subconditions
+                    ]
+                )
+            case OrCondition(subconditions):
+                return OrCondition(
+                    [
+                        _expand_substitute(subcondition, substitutions)
+                        for subcondition in subconditions
+                    ]
+                )
+            case NotCondition(base_condition):
+                return NotCondition(_expand_substitute(base_condition, substitutions))
+            case EqualityCondition(left_side, right_side):
+                return EqualityCondition(
+                    substitutions.get(left_side, left_side),
+                    substitutions.get(right_side, right_side),
+                )
+            case ForallCondition(loop_var, condition):
+                new_subs = dict(substitutions)
+                conditions = []
+                for param in problem.objects_section:
+                    if param.type == loop_var.type:
+                        new_subs[loop_var.value] = param.value
+                        conditions.append(_expand_substitute(condition, new_subs))
+                return AndCondition(conditions)
+            case Predicate(name, assignment):
+                return Predicate(
+                    name,
+                    tuple(
+                        substitutions.get(argument, argument)
+                        for argument in assignment
+                    ),
+                )
+
     precondition_id = _add_condition_to_asp_part(
-        action_definition.precondition,
+        _expand_substitute(action_definition.precondition, {}),
         part,
         IDAllocator.from_id_constructor(RuleID),
         variable_id_allocator,

src/pddlsim/ast.py

@@ -638,6 +638,32 @@ def _as_str_without_location(self) -> str:
     def __repr__(self) -> str:
         return f"(= {self.left_side!r} {self.right_side!r})"
 
+@dataclass(frozen=True)
+class ForallCondition[A: Argument]:
+    """Represents an forall predicate (forall (arg) condition) in PDDL."""
+
+    loop_var: Typed
+    condition: "Condition[A]"
+
+    def _validate(
+        self,
+        parameters: Parameters,
+        objects: Mapping[Object, Type],
+        domain: "Domain",
+    ) -> None:
+
+        scope_dict = dict(parameters._items)
+        scope_dict[self.loop_var.value] = self.loop_var.type
+        self.condition._validate(scope_dict, objects, domain)
+
+    @override
+    def _as_str_without_location(self) -> str:
+        return "forall predicate"
+
+    @override
+    def __repr__(self) -> str:
+        return f"(= {self.left_side!r} {self.right_side!r})"
+
 
 class _SerializedPredicate(TypedDict):
     name: Any
@@ -735,6 +761,7 @@ def __str__(self):
     | OrCondition[A]
     | NotCondition[A]
     | EqualityCondition[A]
+    | ForallCondition[A]
     | Predicate[A]
 )
 """Represents a condition in PDDL, over objects, or variables."""

src/pddlsim/grammar.lark

@@ -64,8 +64,11 @@ EQUALS_SIGN: "="
                     | "(" OR_KEYWORD list_{condition{argument}} ")" -> or_condition
                     | "(" NOT_KEYWORD condition{argument} ")"       -> not_condition
                     | "(" EQUALS_SIGN argument argument ")"         -> equality_condition
+                    | "(" "forall" "(" VARIABLE "-" _type ")" condition{argument} ")"     -> forall_condition
                     | predicate{argument}
 
+                    //| "(" "forall" "(" VARIABLE "-" _type ")" "when" "(" condition{argument} ")" condition{argument} ")"     -> forall_when_condition
+
 not_predicate{argument}: "(" "not" predicate{argument} ")"
 _atom{argument}: predicate{argument}
                | not_predicate{argument}
@@ -109,4 +112,4 @@ _goal_section: "(" ":goal" condition{object_} ")"
 GOALS_KEYWORD: ":goals"
 goals_section: "(" GOALS_KEYWORD list_{condition{object_}} ")"
 
-problem: "(" "define" _problem_name _used_domain_name [[requirements_section{problem_requirement}]] [objects_section] [action_fallibilities_section] [revealables_section] [initialization_section] (_goal_section | goals_section) ")"
+problem: "(" "define" _problem_name _used_domain_name [[requirements_section{problem_requirement}]] [objects_section] [action_fallibilities_section] [revealables_section] [initialization_section] (_goal_section | goals_section) ")"

src/pddlsim/parser.py

@@ -24,6 +24,7 @@
     Effect,
     EqualityCondition,
     FileLocation,
+    ForallCondition,
     GoalsSection,
     GroundedActionSchematic,
     Identifier,
@@ -200,6 +201,14 @@ def equality_condition[A: Argument](
     ) -> EqualityCondition[A]:
         return EqualityCondition(left_side, right_side, location=location)
 
+    def forall_condition[A: Argument](
+        self,
+        loop_var: A,
+        loop_type: A,
+        condition: Condition[A],
+    ) -> ForallCondition[A]:
+        return ForallCondition(Typed(loop_var, loop_type), condition)
+
     def not_predicate[A: Argument](
         self, base_predicate: Predicate[A]
     ) -> NotPredicate[A]:

src/pddlsim/simulation.py

@@ -41,6 +41,7 @@
     Domain,
     Effect,
     EqualityCondition,
+    ForallCondition,
     GroundedAction,
     Identifier,
     NotCondition,
@@ -76,30 +77,39 @@ def _ground_predicate(
 
 
 def _ground_condition(
-    condition: Condition[Argument], grounding: Mapping[Variable, Object]
+    condition: Condition[Argument], grounding: Mapping[Variable, Object], problem: Problem
 ) -> Condition[Object]:
+    """Fold in to use global information for Forall..."""
     match condition:
         case AndCondition(subconditions):
             return AndCondition(
                 [
-                    _ground_condition(subcondition, grounding)
+                    _ground_condition(subcondition, grounding, problem)
                     for subcondition in subconditions
                 ]
             )
         case OrCondition(subconditions):
             return OrCondition(
                 [
-                    _ground_condition(subcondition, grounding)
+                    _ground_condition(subcondition, grounding, problem)
                     for subcondition in subconditions
                 ]
             )
         case NotCondition(base_condition):
-            return NotCondition(_ground_condition(base_condition, grounding))
+            return NotCondition(_ground_condition(base_condition, grounding, problem))
         case EqualityCondition(left_side, right_side):
             return EqualityCondition(
                 _ground_argument(left_side, grounding),
                 _ground_argument(right_side, grounding),
             )
+        case ForallCondition(loop_var, condition):
+            conditions = []
+            for param in problem.objects_section:
+                if param.type == loop_var.type:
+                    instance_grounding = dict(grounding)
+                    instance_grounding[loop_var.value] = param.value
+                    conditions.append(_ground_condition(condition, instance_grounding, problem))
+            return AndCondition(conditions)
         case Predicate():
             return _ground_predicate(condition, grounding)
 
@@ -218,6 +228,7 @@ def _action_definition_asp_parts(
         return {
             action_definition.name: (
                 action_definition_asp_part(
+                    self.problem,
                     action_definition,
                     variable_id_allocator := IDAllocator[
                         Variable
@@ -372,7 +383,7 @@ def apply_grounded_action(self, grounded_action: GroundedAction) -> bool:
         }
 
         if not self.state.does_condition_hold(
-            _ground_condition(action_definition.precondition, grounding)
+            _ground_condition(action_definition.precondition, grounding, self.problem)
         ):
             raise ValueError("grounded action doesn't satisfy precondition")
 
@@ -389,6 +400,7 @@ def apply_grounded_action(self, grounded_action: GroundedAction) -> bool:
 
         return True
 
+
     def _get_groundings(
         self, action_definition: ActionDefinition
     ) -> Generator[Mapping[Variable, Object]]:

src/pddlsim/state.py

@@ -50,7 +50,7 @@ def _make_atom_hold(self, atom: Atom[Object]) -> None:
             case Predicate():
                 self._true_predicates.add(atom)
             case NotPredicate(base_predicate):
-                self._true_predicates.remove(base_predicate)
+                self._true_predicates.discard(base_predicate)
 
     def does_condition_hold(self, condition: Condition[Object]) -> bool:
         """Check if the given grounded condition holds in the state."""