Python Programming for Automated Planning

(define (domain domain-name)
  (:requirements :strips :typing :negative-preconditions)
  
  (:types 
    type1 type2 - object
  )
  
  (:predicates
    (predicate-name ?param1 - type1 ?param2 - type2)
  )
  
  (:action action-name
    :parameters (?var1 - type1 ?var2 - type2)
    :precondition (and
      (predicate1 ?var1)
      (predicate2 ?var1 ?var2)
    )
    :effect (and
      (new-predicate ?var1)
      (not (old-predicate ?var2))
    )
  )
)

(define (problem problem-name)
  (:domain domain-name)
  
  (:objects
    obj1 obj2 - type1
    obj3 obj4 - type2
  )
  
  (:init
    (predicate1 obj1)
    (predicate2 obj1 obj2)
  )
  
  (:goal (and
    (goal-predicate1 obj3)
    (goal-predicate2 obj3 obj4)
  ))
)

from pddlpy import DomainProblem

# Load domain and problem files
domain_file = "domain.pddl"
problem_file = "problem.pddl"

# Create DomainProblem object
dp = DomainProblem(domain_file, problem_file)

# The dp object now contains parsed PDDL information
print(f"Domain: {dp.domain_name}")
print(f"Problem: {dp.problem_name}")

from pddlpy import DomainProblem

dp = DomainProblem('domain.pddl', 'problem.pddl')

# ===== Accessing State =====
# Get current state (set of fluents)
current_state = dp.state
print("Current state:", current_state)

# Get initial state
initial = dp.initial_state
print("Initial state:", initial)

# Get goal conditions
goals = dp.goals
print("Goals:", goals)

# ===== Checking Predicates =====
# Check if a specific fluent is in current state
if ('at', 'robot1', 'kitchen') in dp.state:
    print("Robot is in kitchen!")

# ===== Working with Actions =====
# Get all possible ground actions
all_actions = list(dp.ground_operator())
print(f"Total actions: {len(all_actions)}")

# Find applicable actions in current state
applicable = [a for a in all_actions if dp.is_applicable(a)]
print(f"Applicable actions: {len(applicable)}")

# ===== Applying Actions =====
# Apply an action (modifies state in-place)
action = ('move', 'robot1', 'kitchen', 'bedroom')
if dp.is_applicable(action):
    dp.apply_operator(action)
    print(f"Applied action: {action}")
    print(f"New state: {dp.state}")

# ===== Goal Checking =====
# Check if goal is satisfied
if dp.check_goal():
    print("✅ Goal achieved!")
else:
    print("❌ Goal not yet achieved")

# ===== Copying State =====
# Create a copy to explore without modifying original
dp_copy = dp.copy()
dp_copy.apply_operator(some_action)  # Won't affect dp

from collections import deque
from pddlpy import DomainProblem

def bfs_planner(domain_file, problem_file, max_depth=10):
    """Simple breadth-first search planner using pddlpy"""
    
    # Load problem
    dp = DomainProblem(domain_file, problem_file)
    
    # Initialize search
    queue = deque([(dp, [])])  # (state, plan)
    visited = {frozenset(dp.state)}
    nodes_expanded = 0
    
    while queue:
        current_dp, plan = queue.popleft()
        nodes_expanded += 1
        
        # Goal test
        if current_dp.check_goal():
            print(f"✅ Solution found!")
            print(f"📊 Nodes expanded: {nodes_expanded}")
            print(f"📏 Plan length: {len(plan)}")
            return plan
        
        # Depth limit
        if len(plan) >= max_depth:
            continue
        
        # Expand node
        for action in current_dp.ground_operator():
            if current_dp.is_applicable(action):
                # Create successor
                new_dp = current_dp.copy()
                new_dp.apply_operator(action)
                
                # Check if visited
                state_sig = frozenset(new_dp.state)
                if state_sig not in visited:
                    visited.add(state_sig)
                    new_plan = plan + [action]
                    queue.append((new_dp, new_plan))
    
    print("❌ No solution found")
    return None

# Usage
plan = bfs_planner('blocks-domain.pddl', 'blocks-problem.pddl')

if plan:
    print("\n📋 Plan:")
    for i, action in enumerate(plan, 1):
        print(f"  {i}. {action[0]}({', '.join(action[1:])})")

from collections import deque
from copy import deepcopy

# ========== State Representation ==========
class BlocksWorld:
    """Represents the state of the blocks world"""
    
    def __init__(self):
        self.ontable = set()      # blocks on the table
        self.clear = set()        # blocks with nothing on top
        self.on = {}              # on[x] = y means x is on y
        self.holding = None       # block currently held (or None)
    
    def copy(self):
        """Create a deep copy of the state"""
        new_state = BlocksWorld()
        new_state.ontable = self.ontable.copy()
        new_state.clear = self.clear.copy()
        new_state.on = self.on.copy()
        new_state.holding = self.holding
        return new_state
    
    def __str__(self):
        """String representation of the state"""
        lines = []
        lines.append(f"On table: {sorted(self.ontable)}")
        lines.append(f"Clear: {sorted(self.clear)}")
        lines.append(f"On relations: {self.on}")
        lines.append(f"Holding: {self.holding}")
        return "\n".join(lines)
    
    def signature(self):
        """Get a hashable signature for state comparison"""
        return (
            frozenset(self.ontable),
            frozenset(self.clear),
            frozenset(self.on.items()),
            self.holding
        )

# ========== Action Definitions ==========
class BlocksActions:
    """Defines all possible actions in blocks world"""
    
    @staticmethod
    def can_pickup(state, x):
        """Check if we can pick up block x"""
        return (x in state.ontable and 
                x in state.clear and 
                state.holding is None)
    
    @staticmethod
    def pickup(state, x):
        """Pick up block x from the table"""
        new_state = state.copy()
        new_state.ontable.remove(x)
        new_state.clear.remove(x)
        new_state.holding = x
        return new_state
    
    @staticmethod
    def can_putdown(state, x):
        """Check if we can put down block x"""
        return state.holding == x
    
    @staticmethod
    def putdown(state, x):
        """Put down block x on the table"""
        new_state = state.copy()
        new_state.ontable.add(x)
        new_state.clear.add(x)
        new_state.holding = None
        return new_state
    
    @staticmethod
    def can_stack(state, x, y):
        """Check if we can stack block x on block y"""
        return state.holding == x and y in state.clear
    
    @staticmethod
    def stack(state, x, y):
        """Stack block x on block y"""
        new_state = state.copy()
        new_state.on[x] = y
        new_state.clear.add(x)
        new_state.clear.remove(y)
        new_state.holding = None
        return new_state
    
    @staticmethod
    def can_unstack(state, x, y):
        """Check if we can unstack block x from block y"""
        return (x in state.on and 
                state.on[x] == y and 
                x in state.clear and 
                state.holding is None)
    
    @staticmethod
    def unstack(state, x, y):
        """Unstack block x from block y"""
        new_state = state.copy()
        del new_state.on[x]
        new_state.clear.add(y)
        new_state.clear.remove(x)
        new_state.holding = x
        return new_state

# ========== Planner ==========
class Planner:
    """Simple forward search planner"""
    
    def __init__(self, initial_state, goal_test, actions_class):
        self.initial_state = initial_state
        self.goal_test = goal_test
        self.actions = actions_class
    
    def get_applicable_actions(self, state, blocks):
        """Get all applicable actions in current state"""
        applicable = []
        
        for x in blocks:
            if self.actions.can_pickup(state, x):
                applicable.append(('pickup', x))
            if self.actions.can_putdown(state, x):
                applicable.append(('putdown', x))
            
            for y in blocks:
                if x != y:
                    if self.actions.can_stack(state, x, y):
                        applicable.append(('stack', x, y))
                    if self.actions.can_unstack(state, x, y):
                        applicable.append(('unstack', x, y))
        
        return applicable
    
    def apply_action(self, state, action):
        """Apply an action to a state"""
        action_name = action[0]
        
        if action_name == 'pickup':
            return self.actions.pickup(state, action[1])
        elif action_name == 'putdown':
            return self.actions.putdown(state, action[1])
        elif action_name == 'stack':
            return self.actions.stack(state, action[1], action[2])
        elif action_name == 'unstack':
            return self.actions.unstack(state, action[1], action[2])
        
        return None
    
    def search(self, blocks, max_depth=10):
        """Breadth-first search for a plan"""
        queue = deque([(self.initial_state, [])])
        visited = {self.initial_state.signature()}
        nodes_expanded = 0
        
        while queue:
            current_state, plan = queue.popleft()
            nodes_expanded += 1
            
            # Check if goal is reached
            if self.goal_test(current_state):
                print(f"\n📊 Search Statistics:")
                print(f"   Nodes expanded: {nodes_expanded}")
                print(f"   Plan length: {len(plan)}")
                return plan
            
            # Don't search beyond max depth
            if len(plan) >= max_depth:
                continue
            
            # Try all applicable actions
            for action in self.get_applicable_actions(current_state, blocks):
                new_state = self.apply_action(current_state, action)
                state_sig = new_state.signature()
                
                if state_sig not in visited:
                    visited.add(state_sig)
                    new_plan = plan + [action]
                    queue.append((new_state, new_plan))
        
        return None  # No plan found

# ========== Main Program ==========
def main():
    print("🧱 Blocks World Planner")
    print("=" * 60)
    
    # Define initial state
    initial = BlocksWorld()
    initial.ontable = {'A', 'B'}
    initial.clear = {'A', 'B'}
    initial.on = {}
    initial.holding = None
    
    print("\n📦 Initial State:")
    print(initial)
    print("\n🎯 Goal: Stack A on B (i.e., A is on B)")
    
    # Define goal test
    def goal_test(state):
        return 'A' in state.on and state.on['A'] == 'B'
    
    # Create planner
    planner = Planner(initial, goal_test, BlocksActions)
    
    # Search for a plan
    print("\n🔍 Searching for a plan...")
    plan = planner.search(['A', 'B'])
    
    if plan:
        print(f"\n✅ Plan found with {len(plan)} actions:")
        for i, action in enumerate(plan, 1):
            action_str = f"{action[0]}({', '.join(action[1:])})"
            print(f"   Step {i}: {action_str}")
        
        # Simulate execution
        print("\n🎬 Simulating plan execution:")
        print("=" * 60)
        state = initial
        
        for i, action in enumerate(plan, 1):
            print(f"\nStep {i}: {action[0]}({', '.join(action[1:])})")
            state = planner.apply_action(state, action)
            print(state)
        
        if goal_test(state):
            print("\n🎉 Goal achieved successfully!")
        else:
            print("\n❌ Goal not achieved!")
    else:
        print("\n❌ No plan found!")

if __name__ == "__main__":
    main()