Plan-Space Path Folding

Validation

It was run inside an isolated container with no network access. This is the exact command and the real output it produced — captured process output, not written by a model.

$ python3 plan_space_path_folding.py
Usage: python plan_folder.py <input_data>

A screenshot of that run.

A clean run proves this does what is shown above, in a CPU-only sandbox. It is a small research demo — not a production tool, and nothing here was published anywhere.

The code

All of it — 118 lines, one file, standard library only.

# Modified plan_space_path_folding.py with Symmetry-Aware folding
import hashlib
from path_folder import PathFolder
from collections import defaultdict

class PlanningGraphNode:
    def __init__(self, state, actions):
        self.state = state
        self.actions = actions
        self.predecessors = {}
        self.hash = self._compute_hash()

    def _compute_hash(self):
        hasher = hashlib.sha256()
        hasher.update(str(self.state).encode())
        hasher.update(str(self.actions).encode())
        return hasher.hexdigest()

class PlanningGraph:
    def __init__(self):
        self.nodes = defaultdict(list)
        self.current_node = None
        self.goal_states = []

    def add_node(self, node, parent=None):
        self.nodes[node.hash].append(node)
        if parent:
            node.predecessors[parent.hash] = parent
        if not self.current_node:
            self.current_node = node

    def find_goal_paths(self):
        queue = deque([self.current_node.hash])
        visited = set()
        paths = []
        while queue:
            current_hash = queue.popleft()
            current_node = self.nodes[current_hash][0]
            if current_node.state in self.goal_states:
                paths.append(self._reconstruct_path(current_hash))
                continue
            for prev_hash in current_node.predecessors:
                if prev_hash not in visited:
                    visited.add(prev_hash)
                    queue.append(prev_hash)
        return paths

    def _reconstruct_path(self, hash):
        path = []
        current_hash = hash
        while current_hash in self.nodes:
            node = self.nodes[current_hash][0]
            path.append(node)
            current_hash = next(iter(node.predecessors.keys())) if node.predecessors else None
            if not current_hash:
                break
        return path[::-1]

class SiriusFolding:
    def __init__(self):
        self.folding_rules = {}
        self.compressed_proofs = {}

    def compress_paths(self, paths):
        compressed = {}
        for path in paths:
            # Symmetry-aware key: action sequence hash
            action_seq = '-'.join(['.'.join(node.actions) for node in path])
            key = hashlib.sha256(action_seq.encode()).hexdigest()
            if key not in compressed:
                compressed[key] = []
            compressed[key].append(path)
        
        # Create proofs for each unique action sequence
        proofs = {}
        for key, path_group in compressed.items():
            proof = self._create_proof(path_group)
            proofs[key] = proof
        return proofs

    def _create_proof(self, paths):
        hasher = hashlib.sha256()
        for path in paths:
            for node in path:
                hasher.update(node.hash.encode())
        return hasher.hexdigest()

if __name__ == "__main__":
    import sys
    from collections import deque

    if len(sys.argv) < 2:
        print('Usage: python3 plan_space_path_folding.py <input_file>')
        sys.exit(1)

    # Hard-coded example demonstrating symmetry-aware folding
    graph = PlanningGraph()
    # Create nodes with different states but same actions
    start = PlanningGraphNode('A', ['move_right'])
    middle1 = PlanningGraphNode('B', ['move_left', 'move_right'])
    middle2 = PlanningGraphNode('C', ['move_left', 'move_right'])  # Same actions as middle1
    goal = PlanningGraphNode('GOAL', [])

    # Build graph
    graph.add_node(start)
    graph.add_node(middle1, start)
    graph.add_node(middle2, start)
    graph.add_node(goal, middle1)
    graph.add_node(goal, middle2)
    graph.goal_states = ['GOAL']

    paths = graph.find_goal_paths()
    folder = SiriusFolding()
    proofs = folder.compress_paths(paths)

    print(f'Found {len(proofs)} unique action sequences')
    for pH, proof in proofs.items():
        print(f'Proof {pH[:6]}: Merged {len(proofs[pH])} paths with identical action sequences')