controller program synthesis

Traditional reinforcement learning approaches suffer from low sample efficiency, difficulty in reward design, and lack of interpretability, while handcrafted policies rely heavily on expert knowledge and exhibit limited generalization. This work proposes to frame control policy synthesis as a code evolution problem, introducing EvoToolkit—a novel framework that integrates the programming priors of large language models (LLMs) with evolutionary search to enable training-free, automatic policy generation. By combining LLM-driven code mutation, task-specific fitness evaluation, and evolutionary selection, the method produces compact, human-readable, and executable control policies. These policies achieve strong performance across multiple tasks and inherently support direct inspection, manual modification, and formal verification.

Industrial process control demands interpretable and auditable strategies, a requirement that black-box neural controllers struggle to fulfill. This work proposes the first audit-driven controller synthesis framework tailored for industrial control: leveraging large language models to iteratively generate human-readable Python control programs under physics-informed simulation feedback. The approach integrates structured policy ideation, component-level multi-scenario feedback, and formal verification to automatically guarantee critical properties such as safety and monotonicity. A novel Luby-style universal restarting strategy is introduced to enable efficient, parameter-free search. Evaluated on a hot-rolling steel control task, the method achieves performance comparable to the best outcome from 730 manual tuning trials within only 160 iterations, while producing explicit, expert-auditable control logic.

This study addresses the persistent gap between theoretical control performance and its practical realization in real-world robotic systems, often caused by inadequate discretization, insufficient real-time guarantees, and weak error handling in control software. For the first time from a software engineering perspective, the authors systematically analyze 184 open-source robotic controllers through code review, empirical analysis, and test evaluation, uncovering common deficiencies in application scenarios, implementation details, and verification practices. The findings reveal that most implementations fail to properly account for critical system constraints, and their testing strategies inadequately validate the theoretical assurances they claim. This work highlights a significant disconnect between implementation quality and theoretical promises, offering concrete directions and practical guidelines for developing reliable, verifiable robotic control software.

Black-box neural network policies in dynamic system control suffer from poor interpretability and verifiability. Method: This paper proposes a large language model (LLM)-guided symbolic program evolution framework that automatically synthesizes Python-based, interpretable, and formally verifiable control policies. The approach integrates pre-trained LLMs, evolutionary search, physics-based simulation evaluation, and program synthesis to generate end-to-end transparent controllers in standard, executable code. Contribution/Results: To our knowledge, this is the first work leveraging LLMs to guide symbolic-space evolution of control policies—balancing expressive power with human readability. Evaluated on the cart-pole swing-up and ball-in-cup tasks, the method achieves high control performance while ensuring transparency, reliability, and task adaptability. Open-sourced implementation confirms its advantages over conventional neural policies in terms of explainability, formal verification feasibility, and generalization across control tasks.

To address the lack of domain adaptation and correctness guarantees of large language models (LLMs) in PLC programming, this paper proposes the first fully automated, closed-loop framework for PLC code generation and formal verification tailored to industrial control. Methodologically, it introduces a multi-agent collaborative system integrating retrieval-augmented generation (RAG), chain-of-thought (CoT) reasoning, industrial-domain semantic prompt engineering, and formal specification modeling—enabling end-to-end translation from natural language requirements to formally verifiable PLC code. Key contributions include: (1) the first multi-agent architecture specifically designed for PLC programming; (2) the first benchmark for verifiable PLC code generation, featuring rigorously annotated natural-language specifications and formal safety properties; and (3) substantial improvements over state-of-the-art methods on the proposed benchmark—achieving +32.7% higher pass rate and +41.5% greater specification consistency.

This study addresses the challenges of control design in complex industrial processes characterized by multivariable coupled dynamics by proposing an automated control strategy generation framework that integrates large language models (LLMs) with Bayesian optimization. The approach decomposes control design into structured code generation steps, ensuring physical consistency through execution-based validation and feedback-driven repair. It pioneers the automatic synthesis of decentralized PI controller architectures and their tuning environments directly from dynamic process models. Evaluated on a nonlinear gas preheater benchmark, the generated control schemes—subsequently refined via Bayesian optimization—achieve a 26.5% improvement in closed-loop performance and significantly enhance the transient response of pressure loops, thereby demonstrating the method’s effectiveness and novelty.

This work addresses the challenge of simultaneously achieving high performance and formal guarantees of safety and robustness in learning-based control for safety-critical cyber-physical systems. The paper proposes SMC-ES, a novel framework that deeply integrates evolutionary strategies with statistical model checking to enable provably sound, high-confidence verification of control policies with respect to performance, safety, and robustness. Evaluated on Gymnasium and Safety-Gymnasium benchmarks, SMC-ES attains performance comparable to state-of-the-art model-free deep reinforcement learning (DRL) and safe DRL methods, while incurring only moderate computational overhead. Crucially, it provides rigorous formal guarantees on violation probabilities, thereby bridging a critical gap in the field by offering verifiable assurance for learned control policies that has been largely absent in existing approaches.

Large language models (LLMs) struggle to directly perform low-level robotic control tasks due to the stringent demands for precision, real-time responsiveness, and environmental awareness. This work proposes a closed-loop, modular code synthesis framework that leverages pretrained LLMs to generate structured control programs. By embedding diagnostic probes into the generated code, the system enables iterative execution–feedback–refinement cycles, producing highly accurate and executable control policies without requiring task-specific fine-tuning. Evaluated on a real-world RGB-D vision and robotic arm platform, the approach achieves high accuracy and strong autonomy in both calibration and pick-and-place tasks, demonstrating the practicality and scalability of the proposed framework.

This work addresses the lack of effective control over privilege escalation in existing intelligent systems during dynamic code generation and execution. We propose a "controlled metaprogramming" paradigm that treats program representations as first-class values, decoupling code generation from execution through purely syntactic manipulation and structural inspection mechanisms. Specifically, we reconceptualize eval—not as a language primitive—but as a controlled effect subject to validation against policies, capabilities, and resource constraints. Leveraging formal methods, we define pure syntactic evaluation and controlled materialization judgments, implementing them in MashinTalk, a domain-specific language compiled to BEAM bytecode. Our theoretical guarantees—encompassing purity of syntactic operations, non-bypassability, and boundary preservation—are formally verified within a suite of 454 machine-checked theorems in Rocq.