COOL: Efficient and Reliable Chain-Oriented Objective Logic with Neural Networks Feedback Control for Program Synthesis

TL;DR

The paper addresses the rigidity and unreliability of current program synthesis methods by introducing COOL, a neural-symbolic framework that combines Chain-of-Logic (CoL) with Neural Network Feedback Control (NNFC). CoL provides fine-grained, activity-level control over DSL rule application using heuristic vectors and control keywords, while NNFC leverages a Domain-Specific Neural Network (DSNN) with an inner coupling structure to dynamically adjust the synthesis process and filter mispredictions. Static experiments show large gains in accuracy and substantial reductions in tree operations and time, with NNFC offering additional improvements under challenging conditions. Dynamic results demonstrate robust reliability as task difficulty and domain complexity increase, validating the approach for multi-domain synthesis and highlighting its potential for integration with broader AI tooling and language-model workflows.

Abstract

Program synthesis methods, whether formal or neural-based, lack fine-grained control and flexible modularity, which limits their adaptation to complex software development. These limitations stem from rigid Domain-Specific Language (DSL) frameworks and neural network incorrect predictions. To this end, we propose the Chain of Logic (CoL), which organizes the synthesis process into an activity flow and provides heuristic control to guide the process. Furthermore, by integrating neural networks with libraries and introducing a Neural Network Feedback Control (NNFC) mechanism, our approach modularizes synthesis and mitigates the impact of neural network mispredictions. Experiments on relational and symbolic synthesis tasks show that CoL significantly enhances the efficiency and reliability of DSL program synthesis across multiple metrics. Specifically, CoL improves accuracy by 70% while reducing tree operations by 91% and time by 95%. Additionally, NNFC further boosts accuracy by 6%, with a 64% reduction in tree operations under challenging conditions such as insufficient training data, increased difficulty, and multidomain synthesis. These improvements confirm COOL as a highly efficient and reliable program synthesis framework.

Figures (11)

• Figure 1: Performance Enhancements with CoL and NNFC. The CoL DSL surpasses non-CoL DSL in all metrics. While NNFC increases computation time due to neural network calls, it significantly boosts accuracy in dynamic experiments, enhancing reliability.
• Figure 2: Chain-of-Logic (highlighted part) organizes the rule application into a structured activity flow, enhancing the Domain-Specific Language (DSL) framework's ability to handle complex tasks. The Neural Network Feedback Control mechanism (red path) utilizes data during synthesis to improve the performance of the synthesis process dynamically.
• Figure 3: Heuristic Vectors and Heuristic Values in Chain-of-Logic. Heuristic vectors $\textbf{h}$ decompose the DSL $G$ into multiple sub-DSLs ($G_0, G_1, G_2, G_3$) based on whether the value of the component at the corresponding position is non-zero. These sub-DSLs correspond to the activities depicted in Figure \ref{['fig:col_first_page']} and operate on partial programs $p$ using rules $r$. The synthesis process for each activity is guided by rule application policies $\pi_r$, which are generated by a heuristic algorithm $f$ that uses heuristic values $\textbf{h}[n]$ as input. In the experiments conducted in this paper, we adopt the A* algorithm and treat the heuristic value $\textbf{h}_i[n]$ as a reward for applying the rule $r_i$ during activity $n$ (Algorithm \ref{['alg:A_star']}). Consequently, a higher heuristic value positively influences the rule's application.
• Figure 4: Keywords in Chain-of-Logic. In this illustrative CoL DSL, each node represents a stage or activity where a set of rules can be applied to generate partial programs. The flow between stages is managed by keywords return, logicjump(n), and abort, allowing for the implementation of complex control flow in program synthesis.
• Figure 5: Neural Network Feedback Control. The left side illustrates the complete control loop of NNFC. In the forward flow (green path), heuristic values $u$ guide the synthesis process as control signals. In the feedback loop (red path), the DSNN (Domain-Specific Neural Network, the neural network paired with a DSL) generates initial error signals $e_0$ from partial programs $y$. These singals are then filtered to produce high-quality error signals $e_1$, which adjust the initial heuristic values $u_0$. In multidomain synthesis, the CoL DSL and DSNN from the self-domain use partner domain information (dashed path) to clarify tasks and avoid competition, ensuring modularity. The right side details the feedback loop: The DSNN comprises multiple neural networks coupled in series via noise signals, with each network generating its own error signal $e_0$, then these signals with large discrepancies are filtered, retaining the final high-quality error signals $e_1$. (See Appendix \ref{['app:neural']} for details on the neural network's format, architecture, training, prediction, and role in synthesis.)