acceptodds
Under review as a conference paper at ICLR 2027

AdaptoFlux: A Typed Graph Representation Substrate for Stateful Symbolic Program Synthesis

Abstract

Discrete program synthesis searches a combinatorial space of typed, executable structures, where invalid operator compositions and state-dependent control logic make even well-formed programs hard to discover. We present AdaptoFlux, a representation substrate that couples a metadata-driven Method Pool—registering heterogeneous, typed operations, including side-effectful actions—with Generalized Data Flow Graphs (GDFGs), typed DAGs whose edges are statically checked for type compatibility. State-dependent behavior is accommodated without abandoning the DAG formulation: through time-step unrolling, nodes read from and write to an implicit external state, decoupling mutable state from graph topology. AdaptoFlux deliberately separates the representation space from the search procedure: type constraints prune invalid compositions before search begins, and the same substrate can be paired with arbitrary optimizers. Using lightweight gradient-free search procedures as proof-of-concept probes, we validate the space's navigability, type safety, and interface completeness on canonical static tasks; on a minimal stateful synthesis task, the type-constrained space automatically synthesizes the target stateful graph in 8 of 10 runs, versus 0 of 10 when type routing is disabled. A hand-crafted GDFG controlling a Snake agent further demonstrates that pure computation and side-effecting actions can execute within a single unified graph. AdaptoFlux is a concept-and-feasibility contribution to representation design, not a new optimization algorithm, and is not intended to outperform specialized symbolic-regression systems (e.g., PySR, gplearn) on static benchmarks.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
program synthesis, neuro-symbolic systems, typed graph representation, stateful computation, interpretable models, discrete optimization

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_Eq1uOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Adaptoflux is a typed DAG-based representation framework for symbolic programming syntheis. It combines a method pool of typed operators with a graph representation that supports pure computations and side-effectful operations. The authors employ gradient-free search strategies to demonstrate feasibility.

Critical strengths
  1. The unified interface for composing pure and side-effectful operators is a potentially useful engineering abstraction,
  2. The paper also provides an implementation and several proof-of-concept experiments that are interesting to me.
Critical weaknesses
  1. The proposed framework largely combines well-established components, including typed operators, DAG-based program representations and time-step unrolling. My main concern is that the current version does not establish a sufficiently distinct technical contribution beyond this integration. In particular, I feel like the proposed type system only checks dataflow compatibility without reasoning about stateful effects.. It remains unclear what fundamental capability this representation provides beyond existing approaches. Consider reframing the contrbution part.

  2. The stateful synthesis experiment relies on task-specific type signatures that prescribe the target program structure, making the reported 8/10 vs. 0/10 improvement less convincing. More challenging stateful synthesis tasks remain unsolved, while the Snake controller is hand-crafted. Therefore, it seems that the experiments do not demonstrate the practical value of the proposed representation. Additionally, the paper suffers from formatting and organization problems. There is a large blank region on page 8-9, the figures are not in vector graphics, and a long appendices containing considerable redundant or unnecessary material (consider put them into the codebase). In Section 4.3, the authors write "A central review question was...," the authors need to rewrite this.

Questions for authors
  1. What concrete technical or representational capability does AdaptoFlux provide that cannot be achieved with existing typed DAG-based program synthesis frameworks? By the way, why we can't just use frontier LLMs for this task?

  2. How much of the improvement in stateful synthesis comes from the task-specific type constraints that effectively encode the target program structure? Would the advantage persist under less restrictive type signatures?

1 comment

We clarified the technical contribution and state-execution contract.

Typed DAGs with explicit state can represent the same programs evaluated in our comparison. The concrete contribution is a common execution interface connecting heterogeneous methods, shared subgraphs, stateful actions, and different optimizers, with a state-access contract maintained through training, execution, and persistence. The revision explicitly discusses MT-CGP and SelectionDAG and distinguishes type compatibility from resource-conflict ordering. (§§2–3, 4.4–4.5; Appendices A, C, I)

Type priors contribute substantially, and the benefit persists with less restrictive signatures.

With the same nine operator implementations, nominal search caps, and 30 shared seeds:

Type declarationsInitialization successesFinal strict successes
Separate position/target20/3029/30
Merge into quantity4/3015/30
All scalar0/301/30

Strict success requires solving all 20 initial position–target pairs. Removing the position/target distinction still gives 50% success, compared with 3.3% under all-scalar declarations. We also report realized evaluation counts. (§4.3, Table 1; Appendix B)

Practical validation now includes trained action controllers.

The template combines shared features, action scores, and exclusive routing, with CMA learning coefficients and limited structural growth. Models are trained separately for each task. Across five seeds, mean completion rates are 92.10%, 92.74%, 43.55%, and 100% for Catch, Maze, Snake, and Bird. The representative Bird model contains 44 shared features and 88 score coefficients and passes a 20,480-step consistency replay in the original executor. (§4.7, Figure 1, Table 6; Appendix E)

Section 5 also states our ongoing research goal: enabling a continually learning agent to accumulate executable subgraphs with applicability conditions and supporting evidence across tasks, using unexpectedly beneficial outcomes and contradictory feedback to guide exploration and local revision.

LLMs can serve as candidate generators for this interface.

We propose a workflow in which an LLM suggests candidate graphs or graph edits, and AdaptoFlux checks, executes, and returns task feedback on them. The paper explicitly presents this as a prospective integration direction. (§2; Appendix R)

We corrected the organization and formatting.

The nine-page main text now incorporates the key results. Review-process wording, including “A central review question was…,” has been removed, and large blank regions and problematic text wrapping have been corrected. Principal diagrams and new scaling plots use vector formats. The appendices separate new studies from historical material, with undersized tables and profiling figures reformatted.

Protocols, data, the frozen runtime, and reproduction scripts for the four supplementary studies have been provided in the repository under experiments/rebuttal_20261106/.

Reviewer_Nh1GOpenReview ↗
Rating
2(+1)
Confidence
2
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper presents AdaptoFlux, a representation framework for symbolic program synthesis. It combines a Method Pool of typed operations with Generalized Data Flow Graphs, allowing pure computations and side-effectful actions to be composed within a stored DAG. Stateful behavior is supported through external mutable state and repeated graph execution. The representation is separated from the search procedure, and several gradient-free search methods are used as feasibility probes. The evaluation includes static tasks, a synthetic knowledge-transfer task, and a minimal stateful task where type-constrained search succeeds in 8/10 runs versus 0/10 without type routing. A manually constructed Snake controller further illustrates the execution interface.

Critical strengths
  1. The paper addresses a useful interface problem: composing pure computations and environment-changing actions within a common program representation. Separating the operator registry and execution representation from the search procedure is a reasonable design choice. This could make it easier to study different search methods while keeping the execution interface consistent.

  2. The minimal stateful experiment provides a controlled initial check of type routing. The two conditions use the same nine operator implementations and the same nominal search budget, and the authors report individual-run outcomes. The improvement from 0/10 to 8/10 successful runs supports the usefulness of the supplied type constraints in this setting. The paper also clearly distinguishes this automatic synthesis result from the manually constructed Snake controller.

Critical weaknesses

1. The execution order of side-effectful nodes is unclear.

Section 3.2 acknowledges that state updates depend on execution order. However, a DAG only defines a partial order. If two nodes access the same external state without a dependency path between them, different topological orders may give different results. For example, starting from s = 1, applying s ← s + 1 and then s ← 2s gives 4, while reversing the order gives 3. Eq. 2 does not specify how the order is chosen in this case.

Eq. 3 describes when parallel execution is valid, but it is unclear how these conditions are checked. Appendix H.4 treats side-effect metadata as outside the hypothesis class, while Appendix C.3 states that type constraints eliminate the overhead of runtime data-race detection. Input/output types alone cannot rule out conflicting state accesses.

The implementation may already use a fixed ordering or conflict-handling rule. If so, this should be stated explicitly, together with how the parallel scheduler preserves it. This is an important detail for a framework whose main purpose includes executing stateful programs.

2. The experiments provide limited evidence for the representation's distinct benefit.

The main stateful experiment uses a small, fully observed position-target task. In Appendix C.4, the pos_type and target_type annotations strongly restrict the possible compositions toward the intended solution. The 8/10 versus 0/10 result is a useful type-routing ablation, but it does not show whether the implicit-state GDFG design offers an advantage over other typed representations. The hand-crafted Snake controller shows that the framework can execute a policy, but does not address automatic synthesis.

A comparison with a typed DAG using explicit state threading, under the same operator set and type annotations, would help isolate the contribution. This is more relevant to the paper's claim than outperforming specialized symbolic-regression systems.

The related-work discussion also needs to be more precise. MT-CGP [1] already supports multiple data types in graph-based genetic programming, and LLVM's SelectionDAG [2] represents typed dataflow together with ordering dependencies for side-effectful operations. Their goals differ from this paper's, but the authors should explain which part of the proposed representation goes beyond these existing ideas.

Presentation issue.

The presentation needs substantial improvement. The opening lacks a concrete example or teaser to clarify the proposed representation, while automatic stateful synthesis is demonstrated only on one minimal task. The layout around Figure 3 (pp. 7–8) is particularly poor: text wrapping spills onto the next page, leaves a large blank area, and squeezes the Section 4.3 heading and opening paragraph into a narrow column. Figure 3 also appears to lack a numbered caption. Meanwhile, substantial space on the final main-text page remains unused despite the need for clearer explanations and stronger validation.

References

[1] Harding et al. [MT-CGP: Mixed Type Cartesian Genetic Programming]. GECCO 2012.

[2] LLVM documentation. Introduction to SelectionDAGs.

Questions for authors
  1. Clarification of execution semantics: For two nodes that are unordered by the dataflow graph but access overlapping external state, what determines their execution order? Is this order part of the program representation, a fixed executor convention, or a constraint supplied by the user? How does the parallel scheduler preserve the intended behavior? Please clarify the mechanism already used in the implementation and the assumptions required by its guarantees.

  2. Clarification of the contribution and existing evidence: With the same operator implementations, type annotations, and external interaction loop, what specific capability or search advantage does the implicit-state GDFG provide over a typed DAG with explicit state threading? Does the current submission contain evidence that separates this benefit from the benefit of type constraints alone?

Answers that establish a complete execution contract and a concrete distinction from these alternatives would materially affect my assessment.

1 comment

State-access order is now part of the program representation.

The original executor, V0, scheduled nodes according to data dependencies. The revised executor, V1, defines a program as P=(G,π,Ec)P=(G,\pi,E_c): the data graph, an order selected and stored before its first evaluation, and control dependencies preserving conflicting accesses. Read–write and write–write conflicts follow the stored order, while independent resources remain parallelizable. Types check port compatibility; resource declarations determine state conflicts. We corrected the original statements that conflated these roles.

The order is preserved through training evaluation, copying, and save/load operations. With complete resource declarations, deterministic methods, identical inputs and initial state, and successful execution, legal schedules produce identical results. All 4,934 paired serial/threaded steps across 90 models match; 85 tests and 46 subtests pass. V0 experiments and V1 validation are reported separately. (§§3.2, 4.4, Table 2; Appendices A, P.4)

We added a matched implicit/explicit-state comparison.

We translated the same programs into explicit-state-token DAGs while preserving access order and the interaction loop. Across 1,007 candidate/final-model records and 70,670 paired environment steps, numerical values, states, trajectories, and metrics all match. Explicit encoding adds no operation nodes and an average of 2.189 state edges across final graphs; its median explicit/implicit execution-time ratio is 1.137 in this implementation.

This quantifies encoding correspondence and execution overhead; independently searching explicit-state programs remains a separate comparison. The contribution of type priors is measured by the three-condition ablation, with success counts of 29/30, 15/30, and 1/30. (§§4.3–4.5, Tables 1, 3; Appendices B, C)

We clarified the relationship to prior work and the specific contribution.

The revision directly discusses MT-CGP’s mixed-type graph representation and SelectionDAG’s effect-ordering dependencies. AdaptoFlux is positioned as a common registration and execution interface for symbolic synthesis, connecting heterogeneous operations, shared subgraphs, stateful actions, persistent execution contracts, and different optimizers. (§§2–3; Appendix I)

We added trained action controllers.

The controllers use a template with shared features, action scores, and exclusive routing. CMA learns score coefficients, with limited feature growth. Models are trained separately for each task. Across five training seeds, mean completion rates are 92.10%, 92.74%, 43.55%, and 100% for Catch, Maze, Snake, and Bird. A representative Bird controller matches the source controller and an independent interpreter exactly over 20,480 steps in the original ATF executor. (§4.7, Figure 1, Table 6; Appendix E)

We reorganized the main text and corrected the layout.

The opening now includes a concrete controller example, and the main text incorporates the key validation results. We removed cross-page text wrapping, supplied numbered captions, and used vector formats for the principal diagrams and new scaling plots. The main text is nine pages, with figure placement and page boundaries checked.

Reviewer_C28bOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents AdaptoFlux, a typed dataflow graph framework for stateful symbolic program synthesis. It makes three contributions: unifying pure computation and side-effecting action nodes in one DAG, statically pruning invalid connections via type signatures, and using time-step unrolling to enable cross-step state interaction while keeping storage acyclic. Experiments show explorability on static tasks, 8/10 synthesis success on a minimalist stateful task (0/10 without type constraints), and feasibility for a snake-shaped agent controller. The work is a representation-layer contribution, not a new search algorithm.

Critical strengths

The architecture is clean and easy to follow. The method-pool-plus-dataflow-graph split, the decoupling of static topology from runtime state, and the strict separation of type constraints from search strategy all fit together coherently, and the design looks reproducible.

The controlled experiment is the highlight for me. With and without type routing differ only in signature declarations, yet the success rate goes from 80% to 0%. That is a striking, statistically significant result, and it makes the case for type-constrained pruning very directly.

Critical weaknesses

Scalability is the major gap. Layers are only tested up to 50, with complete failure above 45, and it is unclear whether this reflects a weak search strategy or a limitation of the representation itself. An experiment that fixes layer count and increases node density would help isolate the bottleneck. More broadly, there is no systematic scaling on method-pool size, time-step length, or nodes per graph, so all results remain small-scale.

Questions for authors

All results are currently small-scale. Do you have plans or preliminary results on scaling along: • Method-pool size — how does success rate degrade as more operators are added? • Nodes/edges per graph — what is the practical upper bound for a single GDFG before type-checking or scheduling overhead dominates?

1 comment

The original depth experiment identifies a search-budget bottleneck.

The values 45 and 50 are configured maximum depths. Those runs reached mean depths of only 19.6 and 18.7 before exhausting the 2,500-attempt budget. We now distinguish configured depth, achieved depth, and budget exhaustion, and add a fixed-depth, increasing-width experiment to separate search difficulty from execution scalability. (§§4.1, 4.6; Appendices K.1, D)

Expanding the method pool has a non-monotonic effect on success.

We compare nine pools containing 6–20 operators. Under fixed candidate and interaction budgets, the nested expansion gives:

OperatorsNumerical input pass rateMaze completion
614.01%11.43%
911.45%58.01%
157.72%37.89%
2011.35%6.93%

The results show that task-relevant operator coverage and the additional candidate alternatives jointly affect search performance. (§4.6, Table 4; Appendix F)

Single-graph execution has been tested up to 1,024 operation nodes and 2,176 edges.

With depth fixed at eight and batch size at 32, serial runtime on the original executor increases from 2.127 ms at 32 nodes to 70.586 ms at 1,024 nodes. At the largest size, separately measured type checking and topological preparation take 1.448 ms and 2.310 ms, respectively, and do not dominate execution cost. All 30 graphs pass independent numerical-reference checks. The largest tested size is 1,024 nodes; the practical capacity limit remains unlocated. (§4.6, Figure 3; Appendix D)

We added sustained-execution and long-term reuse results.

The continual-learning application completes 80 sequences of 40 stages, with 239,206,400 input rows checked through native ATF execution. This counts input rows; graph calls can process batches. Increasing library capacity from 32 to 128 reduces mean attainment cost by 9.26% and return-to-task cost by 18.35% for the full configuration. (§4.6, Table 5; Appendices G, H)

Related application results also provide a concrete direction for further scaling.

Our task-specific controllers combine shared features, per-action score branches, and exclusive routing, allowing one computation to serve several competing actions. CMA learns score coefficients, with limited feature growth. A representative Bird controller has 44 shared features and 88 score coefficients and passes a 20,480-step consistency replay in the original ATF executor. (§4.7; Appendix E)

Our ongoing research investigates how a continually learning agent can retain executable subgraphs with applicability conditions and supporting evidence, then reuse or locally revise them across tasks under bounded memory and computation. This extends the scaling question from enlarging a flat operator pool to managing a growing collection of reusable programs. (§5)

Comments on the paper

11 comments

Thank you for continuing the discussion and clarifying your concern about the technical contribution. We agree that ATF offers a modest technical advance over existing typed graph systems.

ATF was developed primarily as a foundational component for subsequent research, providing an implementation basis for constructing and modifying stateful programs and reusing computational subgraphs. The present paper contributes mainly the design, implementation, and empirical evaluation of this component. Our subsequent goal is to investigate continually learning agents in which different candidate-discovery methods use this substrate to accumulate executable subgraphs with applicability conditions and supporting evidence, then reuse or locally revise them as tasks change. This is the main motivation behind developing ATF. (§§3, 5)

The additional comparisons further clarify this positioning. Both ATF and PyTensor complete the discover–register–reuse workflow and produce matching results when executing frozen controllers across four tasks and 21,200 steps. A concrete execution difference is that input-ready, zero-output actions in ATF participate in execution without a path to the numerical output, whereas the tested PyTensor paths retain actions through outputs or shared-variable updates. (§4.8, Appendix I)

In the matched-search comparison with an independent reference DAG, enabling module reuse increases success on the third affine task from 2/30 to 10/30 in both backends. This improvement belongs to the shared reuse policy. The original three-task experiment is correspondingly interpreted as measuring program abstraction under a fixed number of top-level calls. (§4.2, Appendix I)

We have also clarified the attribution of the other results: the type ablation measures the contribution of the supplied semantic type priors; the implicit-versus-explicit-state comparison validates execution correspondence; and the controller-learning results arise from the structural templates, CMA optimization, and structural proposals. (§§4.3, 4.5, 4.7)

We have streamlined the appendices by moving full implementation descriptions, extended derivations, and historical material to the code repository. The main text retains the key results, while the appendices focus on experimental protocols and validation. The revised main text remains within nine pages, and the protocols, raw records, and reproduction scripts for the new comparisons are also available in the repository.

Thank you for the continued discussion. We welcome your thoughts on this contribution framing and would be glad to clarify any specific issues that remain.

Thank you for following up. The revised paper separately reports operator-pool expansion, graph scaling at fixed depth, and sustained execution and reuse, distinguishing search-budget limitations from execution overhead. (§4.6, Appendices D, F–H)

We have also added a typed-DAG comparison under matched search conditions to clarify the source of the module-reuse benefits. (§4.2, Appendix I)

If a specific scalability concern remains unaddressed by these results, we would be glad to continue the discussion and clarify it directly.

Thank you for further clarifying your concern. We agree that the current work does not establish a clear advantage over existing typed graph systems. ATF provides an alternative organization of program construction and execution: in the workflows considered, it can achieve the same behavior as PyTensor through different internal design choices. We believe that explicitly describing and providing a reusable implementation of this alternative also has value as systems research.

For action integration, ATF places computation and environment actions behind the same method interface. Input-ready, zero-output actions can execute without a path to the numerical output; the tested PyTensor interfaces instead retain actions through outputs or updates.

For optimizer extensibility, ATF separates method interfaces from search information. For example, LayerGrow uses type constraints and sampling weights to guide candidate selection. GraphEvo uses structural statistics to extract computational subgraphs and register them back into the method pool for subsequent reuse. This allows optimizers to change search preferences and program-building blocks without rewriting the executor for each strategy or new subgraph.

These workflows can also be implemented in other frameworks. Our contribution claim is to provide connected interfaces and accompanying implementations through which heterogeneous methods, actions, reusable structures, and optimizer-specific search information can work together, forming a foundation for subsequent continual-learning research. We hope to continue discussing the value and scope of these design choices with you.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.