STRIPS Action Representation

class Action:
    def __init__(self, name, precond, add, delete):
        """Initialize a STRIPS action"""
        self.name = name
        self.precond = set(precond)   # Preconditions (must be true)
        self.add = set(add)            # Add list (becomes true)
        self.delete = set(delete)      # Delete list (becomes false)
    
    def applicable(self, state):
        """Check if action can be applied to the given state"""
        return self.precond.issubset(state)
    
    def apply(self, state):
        """Apply action: Result(s, a) = (s - Del(a)) ∪ Add(a)"""
        return (state - self.delete) | self.add
    
    def __repr__(self):
        return self.name

class STRIPSProblem:
    def __init__(self, initial, goal, actions):
        """Initialize a STRIPS planning problem"""
        self.initial = set(initial)   # Initial state (set of facts)
        self.goal = set(goal)          # Goal state (set of facts)
        self.actions = actions         # List of available actions
    
    def goal_reached(self, state):
        """Check if goal is satisfied in the given state"""
        return self.goal.issubset(state)
    
    def get_applicable_actions(self, state):
        """Get all actions applicable in the given state"""
        return [a for a in self.actions if a.applicable(state)]

# Define initial state
initial_state = {
    "ontable(A)", 
    "ontable(B)", 
    "clear(A)", 
    "clear(B)", 
    "handempty"
}

# Define goal
goal = {"on(A,B)"}

# Define actions
actions = [
    Action(
        "pick-up(A)",
        precond={"ontable(A)", "clear(A)", "handempty"},
        add={"holding(A)"},
        delete={"ontable(A)", "clear(A)", "handempty"}
    ),
    Action(
        "pick-up(B)",
        precond={"ontable(B)", "clear(B)", "handempty"},
        add={"holding(B)"},
        delete={"ontable(B)", "clear(B)", "handempty"}
    ),
    Action(
        "stack(A,B)",
        precond={"holding(A)", "clear(B)"},
        add={"on(A,B)", "clear(A)", "handempty"},
        delete={"holding(A)", "clear(B)"}
    ),
    Action(
        "stack(B,A)",
        precond={"holding(B)", "clear(A)"},
        add={"on(B,A)", "clear(B)", "handempty"},
        delete={"holding(B)", "clear(A)"}
    )
]

# Create problem instance
problem = STRIPSProblem(initial_state, goal, actions)

# Test: Check what actions are applicable
print("Initial state:", problem.initial)
print("Applicable actions:", problem.get_applicable_actions(problem.initial))

from collections import deque

def forward_search(problem, max_depth=10):
    """
    Simple breadth-first forward search planner
    Returns: list of action names forming a plan, or None if no plan found
    """
    # Queue stores: (current_state, plan_so_far)
    frontier = deque([(problem.initial, [])])
    visited = {frozenset(problem.initial)}
    nodes_expanded = 0
    
    while frontier:
        state, plan = frontier.popleft()
        nodes_expanded += 1
        
        # Goal test
        if problem.goal_reached(state):
            print(f"✅ Solution found!")
            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
        
        # Expand node: try all applicable actions
        for action in problem.get_applicable_actions(state):
            new_state = action.apply(state)
            state_signature = frozenset(new_state)
            
            if state_signature not in visited:
                visited.add(state_signature)
                new_plan = plan + [action.name]
                frontier.append((new_state, new_plan))
    
    print("❌ No solution found")
    return None

# Run the planner
print("\n🔍 Searching for a plan...")
print("=" * 50)
plan = forward_search(problem)

if plan:
    print("\n📋 Plan Found:")
    for i, action_name in enumerate(plan, 1):
        print(f"  {i}. {action_name}")
    
    # Verify by executing the plan
    print("\n🎬 Executing plan step-by-step:")
    state = problem.initial
    print(f"Initial: {state}")
    
    for action_name in plan:
        action = next(a for a in problem.actions if a.name == action_name)
        state = action.apply(state)
        print(f"After {action_name}: {state}")
    
    print(f"\n🎯 Goal {'✅ ACHIEVED' if problem.goal_reached(state) else '❌ NOT ACHIEVED'}!")