SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1908.01362 · 2019

ASNets: Deep Learning for Generalised Planning

arXiv · PDF · Open in the Atlas

Code that ran

12 of 18 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 12 have no contract verdict; 0 failures of our instrument; 6 no recorded run), measured 2026-11-21; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1908.01362.json · badge: /api/ran/1908.01362.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
qxcv/asnets canonical (classifier label)
classifier basis: census
12 ran · 6 no recorded run
FunctionStatusWhere it lives
extract_all_domains_problems Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/pddl_utils.py
code served (permissive licence) · get_code("1d44813d2c760247")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tempfile
import os

# Create temporary PDDL files for testing
temp_dir = tempfile.mkdtemp()

# Create a simple domain PDDL file
domain_pddl = """
(define (domain simple-domain)
  (:requirements :strips :typing)
  (:types location - object)
  (:predicates (at ?obj - object ?loc - location))
  (:action move
    :parameters (?from ?to - location)
    :precondition (at ?obj ?from)
    :effect (at ?obj ?to)))
"""

# Create a simple problem PDDL file
problem_pddl = """
(define (problem simple-problem)
  (:domain simple-domain)
  (:objects
    loc1 loc2 - location)
  (:init
    (at obj loc1))
  (:goal
    (at obj loc2)))
"""

# Write files
domain_file = os.path.join(temp_dir, "domain.pddl")
problem_file = os.path.join(temp_dir, "problem.pddl")

with open(domain_file, 'w') as f:
    f.write(domain_pddl)

with open(problem_file, 'w') as f:
    f.write(problem_pddl)

# Create list of PDDL files
pddl_files = [domain_file, problem_file]

ARGS = {
    'pddl_files': pddl_files
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
find_tail_cycle Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/py_utils.py
code served (permissive licence) · get_code("01894c8c99a5c3bc")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Test case 1: Simple repeating cycle at the end
item_list_1 = [1, 2, 3, 1, 2, 1, 2, 1, 2]
max_cycle_len_1 = 3

# Test case 2: No cycle
item_list_2 = [1, 2, 3, 4, 5]
max_cycle_len_2 = 3

# Test case 3: Longer repeating pattern
item_list_3 = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'a', 'b', 'c']
max_cycle_len_3 = 5

# Use the first test case as the main example
ARGS = {
    "item_list": [1, 2, 1, 2, 1, 2],
    "max_cycle_len": 3
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
format_state_for_ssipp Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/ssipp_interface.py
code served (permissive licence) · get_code("ca7dfed8da5f2147")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

class PropObject:
    def __init__(self, identifier):
        self.identifier = identifier

# Create test prop objects with valid SSiPP format
prop1 = PropObject("(at robot loc1)")
prop2 = PropObject("(holding obj1)")
prop3 = PropObject("(clear loc2)")

# Create all_props list with (prop_obj, truth) tuples
# Include both True and False values to test the filtering logic
all_props = [
    (prop1, True),
    (prop2, False),
    (prop3, True),
]

ARGS = {
    "all_props": all_props,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_plan_file_path Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/fd_interface.py
code served (permissive licence) · get_code("d92b7dc4a1776ba4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import tempfile
import shutil

# Create a temporary directory with test files
temp_dir = tempfile.mkdtemp()

# Create test plan files
# Case 1: Simple plan file (non-anytime planner)
with open(os.path.join(temp_dir, "sas_plan"), "w") as f:
    f.write("dummy plan content")

# Case 2: Anytime planner files with stage numbers
with open(os.path.join(temp_dir, "sas_plan.1"), "w") as f:
    f.write("stage 1 plan")

with open(os.path.join(temp_dir, "sas_plan.2"), "w") as f:
    f.write("stage 2 plan")

with open(os.path.join(temp_dir, "sas_plan.5"), "w") as f:
    f.write("stage 5 plan")

# Define arguments
ARGS = {
    "root_dir": temp_dir,
    "base_name": "sas_plan"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
make_bound_prop Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/prob_dom_meta.py
code served (permissive licence) · get_code("8db9068b171ab385")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned BoundProp. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from functools import lru_cache, total_ordering

torch.manual_seed(0)

# Create a minimal stand-in class for a term with a name attribute
class Term:
    def __init__(self, name):
        self.name = name

# Create a minimal stand-in class for a predicate with a name attribute
class Predicate:
    def __init__(self, name):
        self.name = name

# Create a minimal stand-in class for a ground proposition with predicate and terms
class GroundProp:
    def __init__(self, predicate, terms):
        self.predicate = predicate
        self.terms = terms

# Construct the mdpsim_ground_prop argument
pred = Predicate("at")
term1 = Term("robot")
term2 = Term("location_a")
mdpsim_ground_prop = GroundProp(pred, [term1, term2])

ARGS = {
    "mdpsim_ground_prop": mdpsim_ground_prop
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type BoundProp — a BoundProp output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a BoundProp output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
make_unbound_prop Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/prob_dom_meta.py
code served (permissive licence) · get_code("c70adc0ea5536072")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned UnboundProp. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from functools import lru_cache, total_ordering

class UnboundProp:
    """Represents a proposition which may have free parameters (e.g. as it will
    in an action). .bind() will ground it."""

    def __init__(self, pred_name, params):
        self.pred_name = pred_name
        self.params = tuple(params)
        assert isinstance(self.pred_name, str)
        assert all((isinstance(p, str) for p in self.params))

    def __repr__(self):
        return 'UnboundProp(%r, %r)' % (self.pred_name, self.params)

    def bind(self, bindings):
        assert isinstance(bindings, dict), 'expected dict of named bindings'
        args = []
        for param_name in self.params:
            if param_name[0] != '?':
                arg = param_name
            else:
                if param_name not in bindings:
                    raise ValueError("needed bind for parameter %s, didn't get one" % param_name)
                arg = bindings[param_name]
            args.append(arg)
        return BoundProp(self.pred_name, args)

    def __eq__(self, other):
        if not isinstance(other, UnboundProp):
            return NotImplemented
        return self.pred_name == other.pred_name and self.params == other.params

    def __hash__(self):
        return hash(self.pred_name) ^ hash(self.params)

@total_ordering
class BoundProp:
    """Represents a ground proposition."""

    def __init__(self, pred_name, arguments):
        self.pred_name = pred_name
        self.arguments = tuple(arguments)
        self.unique_ident = self._compute_unique_ident()
        assert isinstance(self.pred_name, str)
        assert all((isinstance(p, str) for p in self.arguments))

    def __repr__(self):
        return 'BoundProp(%r, %r)' % (self.pred_name, self.arguments)

    def _compute_unique_ident(self):
        unique_id = ' '.join((self.pred_name,) + self.arguments)
        return unique_id

    def __eq__(self, other):
        if not isinstance(other, BoundProp):
            return NotImplemented
        return self.unique_ident == other.unique_ident

    def __lt__(self, other):
        if not isinstance(other, BoundProp):
            return NotImplemented
        return self.unique_ident < other.unique_ident

    def __hash__(self):
        return hash(self.unique_ident)

def make_unbound_prop(mdpsim_lifted_prop):
    pred_name = mdpsim_lifted_prop.predicate.name
    terms = [t.name for t in mdpsim_lifted_prop.terms]
    return UnboundProp(pred_name, terms)


class MockTerm:
    def __init__(self, name):
        self.name = name


class MockPredicate:
    def __init__(self, name):
        self.name = name


class MockLiftedProp:
    def __init__(self, predicate_name, term_names):
        self.predicate = MockPredicate(predicate_name)
        self.terms = [MockTerm(name) for name in term_names]


ARGS = {
    'mdpsim_lifted_prop': MockLiftedProp('on', ['block_a', 'block_b'])
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type UnboundProp — a UnboundProp output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a UnboundProp output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_problem_args Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/mdpsim_utils.py
code served (permissive licence) · get_code("fab473cbc462543e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

class MockMDPSimModule:
    """Mock mdpsim module for testing parse_problem_args"""
    
    def __init__(self):
        self.files_parsed = []
        self.problems = {
            'problem_1': {'name': 'problem_1', 'state': [1, 2, 3]},
            'problem_2': {'name': 'problem_2', 'state': [4, 5, 6]},
        }
    
    def parse_file(self, pddl_path):
        """Simulate parsing a PDDL file"""
        self.files_parsed.append(pddl_path)
        # Return True for successful parse
        return True
    
    def get_problems(self):
        """Return the loaded problems dictionary"""
        return self.problems


# Create mock module instance
mdpsim_module = MockMDPSimModule()

# Create list of PDDL file paths (as strings, no actual file I/O)
pddls = [
    '/path/to/domain.pddl',
    '/path/to/problem.pddl'
]

# Define ARGS dict with all parameters
ARGS = {
    'mdpsim_module': mdpsim_module,
    'pddls': pddls,
    'problem_name': 'problem_1'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_sexprs Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/pddl_utils.py
code served (permissive licence) · get_code("eba72f2486b730d0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned HList. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re
import weakref

def _ppddl_tokenize(ppddl_txt):
    """Break PPDDL into tokens (brackets, non-bracket chunks)"""
    lines = ppddl_txt.splitlines()
    mod_lines = []
    for line in lines:
        try:
            semi_idx = line.index(';')
        except ValueError:
            pass
        else:
            line = line[:semi_idx]
        mod_lines.append(line)
    ppddl_txt = '\n'.join(mod_lines)
    ppddl_txt = ppddl_txt.lower()
    matches = re.findall('\\(|\\)|[^\\s\\(\\)]+', ppddl_txt)
    return matches

class HList(list):
    """Class for hierarchical list. Helpful because you can get at parent from
    current node (or see that current node is root if no parent)."""

    def __init__(self, parent):
        super().__init__()
        self.is_root = parent is None
        self._parent_ref = weakref.ref(parent) if not self.is_root else None

    @property
    def parent(self):
        if self.is_root:
            return None
        return self._parent_ref()

def parse_sexprs(ppddl_txt):
    """Hacky parse of sexprs from ppddl."""
    tokens = _ppddl_tokenize(ppddl_txt)
    parse_root = parse_ptr = HList(None)
    tokens_reverse = tokens[::-1]
    while tokens_reverse:
        token = tokens_reverse.pop()
        if token == '(':
            new_ptr = HList(parse_ptr)
            parse_ptr.append(new_ptr)
            parse_ptr = new_ptr
        elif token == ')':
            parse_ptr = parse_ptr.parent
        else:
            parse_ptr.append(token)
    return parse_root


ppddl_txt = """
(define (domain blocksworld)
  (:requirements :strips :typing)
  (:types block)
  (:predicates (on ?x ?y) (clear ?x))
  (:action move
    :parameters (?x ?y ?z - block)
    :precondition (and (on ?x ?y) (clear ?x))
    :effect (and (on ?x ?z) (not (on ?x ?y)))))
"""

ARGS = {
    "ppddl_txt": ppddl_txt
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type HList — a HList output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
set_up_ssipp Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/ssipp_interface.py
code served (permissive licence) · get_code("29bb436de3ba7e0b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from unittest.mock import Mock, MagicMock


class MockSSIPPModule:
    """Mock SSIPP module that simulates PDDL parsing and problem initialization."""
    
    def __init__(self):
        self.files_read = []
        self.pddl_data = {}
    
    def readPDDLFile(self, file_path):
        """Mock method to read PDDL files."""
        self.files_read.append(file_path)
        self.pddl_data[file_path] = f"parsed_content_of_{file_path}"
    
    def init_problem(self, problem_name):
        """Mock method to initialize a problem from parsed PDDL."""
        problem = {
            "name": problem_name,
            "domain": "logistics",
            "objects": ["truck1", "package1", "location1"],
            "initial_state": {"at": [("truck1", "location1")]},
            "goal": {"at": [("package1", "location1")]}
        }
        return problem


# Create mock SSIPP module instance
ssipp_module = MockSSIPPModule()

# Create mock PDDL file paths (no actual files needed)
pddl_paths = [
    "/mock/domain.pddl",
    "/mock/problem.pddl"
]

# Define problem name
problem_name = "logistics_problem_1"

# Construct ARGS dict with all required parameters
ARGS = {
    "ssipp_module": ssipp_module,
    "pddl_paths": pddl_paths,
    "problem_name": problem_name
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
strip_parens Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/py_utils.py
code served (permissive licence) · get_code("2776f2994efc5176")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

def strip_parens(thing):
    """Convert string of form `(foo bar baz)` to `foo bar baz` (i.e. strip
    leading & trailing parens). More complicated than it should be b/c it does
    safety checks to catch my bugs :)"""
    assert len(thing) > 2 and thing[0] == '(' and (thing[-1] == ')'), "'%s' does not look like it's surrounded by parens" % (thing,)
    stripped = thing[1:-1]
    assert '(' not in stripped and ')' not in stripped, "parens in '%s' aren't limited to start and end" % (thing,)
    return stripped

ARGS = {
    'thing': '(foo bar baz)'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
to_local Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/multiprob.py
code served (permissive licence) · get_code("211a1968113927a3")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from copy import deepcopy

torch.manual_seed(0)

# The function `to_local` takes a single parameter `obj` and returns deepcopy(obj)
# It doesn't call any methods on obj, just deepcopies it
# We can pass any serializable object

# Create a diverse test object that can be deepcopied
test_obj = {
    "tensor": torch.randn(2, 4),
    "list": [1, 2, 3],
    "nested_dict": {"a": 10, "b": torch.randn(3, 4)},
    "string": "hello",
    "number": 42,
}

ARGS = {
    "obj": test_obj
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
weak_ref_to Ran
ran on a synthesized input
qxcv/asnets/asnets/asnets/py_utils.py
code served (permissive licence) · get_code("ef639be154fac681")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ProxyType. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from weakref import proxy, ProxyTypes

# Test with a simple object that can be weakly referenced
class SimpleObject:
    def __init__(self, value):
        self.value = value

# Create a real object
obj = SimpleObject(42)

# Create a weak reference to it
weak_ref = proxy(obj)

# Test case 1: passing a regular object
regular_object = SimpleObject(100)

# Test case 2: passing None
none_value = None

# Test case 3: passing an existing weak reference
existing_weak_ref = proxy(SimpleObject(200))

# Map all parameters to values
ARGS = {
    'obj': regular_object
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ProxyType — a ProxyType output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ProxyType output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
can_profile Not yet run
unverified (harvested, no recorded run)
qxcv/asnets/asnets/asnets/prof_utils.py
code served (permissive licence) · get_code("f3b50583da62f483")
How it ran

no invocation recorded.

hlist_to_sexprs Not yet run
unverified (harvested, no recorded run)
qxcv/asnets/asnets/asnets/pddl_utils.py
code served (permissive licence) · get_code("4460d2adcc6338aa")
How it ran

no invocation recorded.

make_unbound_action Not yet run
unverified (harvested, no recorded run)
qxcv/asnets/asnets/asnets/prob_dom_meta.py
code served (permissive licence) · get_code("facfe8f2ba36c6f5")
How it ran

no invocation recorded.

run_fd_or_timeout Not yet run
unverified (harvested, no recorded run)
qxcv/asnets/asnets/asnets/fd_interface.py
code served (permissive licence) · get_code("5ee146b62834fec7")
How it ran

no invocation recorded.

run_fd_raw Not yet run
unverified (harvested, no recorded run)
qxcv/asnets/asnets/asnets/fd_interface.py
code served (permissive licence) · get_code("7434fe8e7707e998")
How it ran

no invocation recorded.

wait_exists_polling Not yet run
unverified (harvested, no recorded run)
qxcv/asnets/asnets/asnets/multiprob.py
code served (permissive licence) · get_code("004f8baf6f764d3b")
How it ran

no invocation recorded.

Also present in other papers' code

Of 18 samples lifted from this paper's linked repositories, 18 carry a function identity and 0 do not. Of the 18 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 18 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-21.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

In this paper, we discuss the learning of generalised policies for probabilistic and classical planning problems using Action Schema Networks (ASNets). The ASNet is a neural network architecture that exploits the relational structure of (P)PDDL planning problems to learn a common set of weights that can be applied to any problem in a domain. By mimicking the actions chosen by a traditional, non-learning planner on a handful of small problems in a domain, ASNets are able to learn a generalised reactive policy that can quickly solve much larger instances from the domain. This work extends the ASNet architecture to make it more expressive, while still remaining invariant to a range of symmetries that exist in PPDDL problems. We also present a thorough experimental evaluation of ASNets, including a comparison with heuristic search planners on seven probabilistic and deterministic domains, an extended evaluation on over 18,000 Blocksworld instances, and an ablation study. Finally, we show that sparsity-inducing regularisation can produce ASNets that are compact enough for humans to understand, yielding insights into how the structure of ASNets allows them to generalise across a domain.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("1908.01362")
get_code_for_paper("1908.01362")
have("1908.01362")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/1908.01362.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/1908.01362.svg)](https://syntology.ai/paper/1908.01362)

Connect an agent — have() is free.