Existing Programming-By-Example (PBE) systems often rely on simplified benchmarks that fail to capture the high structural complexity of real-world regexes, such as deeper nesting and frequent use of union operations. To overcome the resulting performance drop, we propose ReSyn, a synthesizer-agnostic divide-and-conquer framework that decomposes complex synthesis problem into manageable sub-problems. We also introduce Set2Regex, a parameter-efficient synthesizer capturing the permutation invariance of examples. Experimental results demonstrate that ReSyn significantly boosts accuracy across various synthesizers, and its combination with Set2Regex establishes a new state-of-the-art on challenging real-world benchmark. The complete source code, datasets, and pre-trained model checkpoints are publicly available at https://github.com/mrseongminkim/ReSyn.

In cooperative multi-agent reinforcement learning (MARL), the permutation problem—where the state space grows exponentially with the number of agents—reduces sample efficiency. Additionally, many existing architectures struggle with scalability, as they rely on a fixed structure tied to a specific number of agents, limiting their applicability to environments with variable entity counts. While approaches such as graph neural networks (GNNs) and self-attention mechanisms have made progress in addressing these challenges, they have significant limitations: dense GNNs and self-attention mechanisms incur high computational costs. To overcome these limitations, we propose an architecture composed of a novel agent network and a scalable non-linear mixing network, both of which ensure permutation-freeness and scalability, enabling generalization to environments with variable numbers of agents. Our agent network significantly reduces the computational complexity of attention from $O(n^{2}d)$ to $O(nd)$ , and our scalable hypernetwork enables efficient weight generation for non-linear mixing. Additionally, we introduce curriculum learning to improve training efficiency. Experiments on StarCraft Multi-Agent Challenge v2 (SMACv2) and Google Research Football (GRF) show that our proposed method generally outperforms representative MARL baselines, including HPN, UPDeT, VDN, and QMIX-based variants, particularly on SMACv2 scenarios with varying numbers and types of agents.

Existing Programming-By-Example (PBE) systems often rely on simplified benchmarks that fail to capture the high structural complexity of real-world regexes, such as deeper nesting and frequent use of union operations. To overcome the resulting performance drop, we propose ReSyn, a synthesizer-agnostic divide-and-conquer framework that decomposes complex synthesis problem into manageable sub-problems. We also introduce Set2Regex, a parameter-efficient synthesizer capturing the permutation invariance of examples. Experimental results demonstrate that ReSyn significantly boosts accuracy across various synthesizers, and its combination with Set2Regex establishes a new state-of-the-art on challenging real-world benchmark. The complete source code, datasets, and pre-trained model checkpoints are publicly available at https://github.com/mrseongminkim/ReSyn.

In cooperative multi-agent reinforcement learning (MARL), the permutation problem—where the state space grows exponentially with the number of agents—reduces sample efficiency. Additionally, many existing architectures struggle with scalability, as they rely on a fixed structure tied to a specific number of agents, limiting their applicability to environments with variable entity counts. While approaches such as graph neural networks (GNNs) and self-attention mechanisms have made progress in addressing these challenges, they have significant limitations: dense GNNs and self-attention mechanisms incur high computational costs. To overcome these limitations, we propose an architecture composed of a novel agent network and a scalable non-linear mixing network, both of which ensure permutation-freeness and scalability, enabling generalization to environments with variable numbers of agents. Our agent network significantly reduces the computational complexity of attention from $O(n^{2}d)$ to $O(nd)$ , and our scalable hypernetwork enables efficient weight generation for non-linear mixing. Additionally, we introduce curriculum learning to improve training efficiency. Experiments on StarCraft Multi-Agent Challenge v2 (SMACv2) and Google Research Football (GRF) show that our proposed method generally outperforms representative MARL baselines, including HPN, UPDeT, VDN, and QMIX-based variants, particularly on SMACv2 scenarios with varying numbers and types of agents.

Recent advances in deep neural networks have achieved state-of-the-art performance across vision and natural language processing tasks. In practice, however, most models are treated as monolithic black-box functions, limiting maintainability, component-wise optimization, and systematic testing and verification. Despite extensive work on pruning and empirical decomposition, the field still lacks a principled semantic notion of when a neural network can be meaningfully decomposed. We introduce neural decompositionality, a formal notion defined as a semantic-preserving abstraction over neural architectures. Our key insight is that decompositionality should be characterized by the preservation of semantic behavior along the model's decision boundary, which governs classification outcomes. This yields a semantic contract between the original model and its components, enabling a rigorous formulation of decomposition. Building on this foundation, we develop a boundary-aware framework, SAVED (Semantic-Aware Verification-Driven Decomposition), which operationalizes the proposed definition. SAVED combines counterexample mining over low logic-margin inputs, probabilistic coverage, and structure-aware pruning to construct decompositions that preserve decision-boundary semantics. We evaluate our approach on CNNs, language Transformers, and Vision Transformers. Results show clear architectural differences: language Transformers largely preserve boundary semantics under decomposition, whereas vision models frequently violate the decompositionality criterion, indicating intrinsic limits. Overall, our work establishes decompositionality as a formally definable and empirically testable property, providing a foundation for modular reasoning about neural networks.

Current code generation evaluation measures functional correctness on well-formed inputs that satisfy all input preconditions.This paradigm has a critical limitation: task descriptions often leave these preconditions implicit, while evaluation filters out inputs that violate them.As a result, generated code may achieve high pass@k scores while failing to enforce the preconditions that the task actually requires.To address this gap, we introduce ContractEval, a benchmark for evaluating whether generated code enforces such preconditions-commonly referred to as contracts.Built on HumanEval+ and MBPP+, ContractEval consists of 364 tasks, each with three components: (i) descriptions reconstructed to explicitly state the contracts, (ii) test cases synthesized through a neurosymbolic pipeline that pairs an LLM with an SMT solver to evaluate whether generated code satisfies these contracts, and (iii) reference code combined with contracts.Using ContractEval to evaluate five representative open-source code LLMs, we reveal a stark disparity between functional correctness and contract satisfaction.Under standard prompting, these models achieve pass@1 of 75-82% with 0% contract satisfaction.Even when contracts are explicitly stated in the prompt, the satisfaction rate reaches only 23-41%.This indicates that current LLMs struggle to satisfy contracts in their generated code, establishing contract satisfaction as a crucial and previously overlooked axis of code generation quality.Our code is available at https://github. com/suhanmen/ContractEval.

Software testing is an essential but cost-intensive work in the software development process. Automatic test case generation tools are utilized to distinguish between the correct and the incorrect solutions more effectively than manually generating them. Many researchers have recently proposed deep learning-based methods to generate test cases automatically for given logical specifications of problems or programs. In this work, we propose teaching the large language models (LLMs) such as ChatGPT and Google Gemini to generate ‘test case grammars’ from problem specifications, particularly using the chain-of-thought (CoT) prompting. Additionally, we implemented it using the CoT to verify and by providing the details of generalized rules to the LLMs, termed “chain-of-verification” (CoVe). We further evaluate our method with the publicly available dataset, DeepMind CodeContests dataset, which consists of numerous programming problems ranging from beginner to advanced level and is submitted by programming students with test cases for verifying the correctness of programs.

Automated Test Case Generation (ATCG) is crucial for evaluating software reliability, particularly in competitive programming where robust algorithm assessments depend on diverse and accurate test cases. However, existing ATCG methods often fail to meet complex specifications or generate effective corner cases, limiting their utility. In this work, we introduce Context-Free Grammars with Counters (CCFGs), a formalism that captures both syntactic and semantic structures in input specifications. Using a fine-tuned CodeT5 model, we translate natural language input specifications into CCFGs, enabling the systematic generation of high-quality test cases. Experiments on the CodeContests dataset demonstrate that CCFG-based test cases outperform baseline methods in identifying incorrect algorithms, achieving significant gains in validity and effectiveness. Our approach provides a scalable and reliable grammar-driven framework for enhancing automated competitive programming evaluations.