operator variant design

Modular control-flow handling in abstract interpretation and supporting multiple analysis strategies—such as path- vs. flow-sensitivity, forward vs. backward directionality, and upper vs. lower approximations—traditionally relies on complex monad transformers, leading to implementation brittleness and poor composability. Method: This paper introduces the *cumulative abstract semantics* framework, the first to incorporate *scoped effects* into abstract interpretation. It decouples syntactic structure from semantic behavior via two classes of effect handlers: *syntax-resolving* and *domain-semantics-introducing*. A single syntax-driven interpreter suffices to generate diverse dynamic evaluators and static analyzers. Contribution/Results: The framework eliminates heavyweight data structures, preserving expressiveness while drastically reducing implementation complexity for multi-strategy analyses. It enhances maintainability, composability, and modularity—providing a concise, unified, and extensible theoretical and practical foundation for modular program analysis.

Understanding the interaction between modular CMA-ES algorithm configurations and problem characteristics remains challenging, as performance varies significantly across optimization problems. Method: Leveraging the BBOB benchmark suite (5D/30D), we propose an “algorithm footprint” modeling framework that quantitatively characterizes how configuration performance responds to landscape features—including condition number, non-convexity, and anisotropy. Contribution/Results: By analyzing footprints across 24 benchmark functions, we identify both universal behavioral patterns and configuration-specific response mechanisms. This work establishes, for the first time, an interpretable, systematic mapping between problem features and configuration preferences. The resulting framework enhances transparency and reliability in black-box optimization—particularly for algorithm selection and adaptive configuration—by grounding empirical performance in explainable landscape-aware principles.

This work addresses the challenge of balancing precision and efficiency in static analysis for sharing and linearity in logic programs, where theoretically optimal abstract operators are often too complex to implement effectively. Building upon the PLAI analyzer in the CiaoPP preprocessor, this study presents the first implementation and integration of multiple optimal abstract operators for unification and matching within a real-world analysis framework. The authors systematically evaluate the impact of these operators on both analysis precision and runtime performance. Experimental results quantitatively demonstrate the accuracy gains achieved by enhancing operator precision alongside the associated computational overhead, offering crucial empirical evidence for navigating the trade-off between precision and efficiency in static program analysis.

Resource-constrained embedded devices require lightweight, customizable compilers, yet existing solutions lack modularity and adaptability for diverse educational and prototyping scenarios. Method: This paper designs and implements a modular, progressively executable C subset compiler. It introduces a staged-executable modular architecture enabling on-demand addition or removal of language features and dynamic subset customization. The design integrates industrial-grade module decomposition, standardized documentation, and a cross-platform backend to enhance maintainability and embedded-system compatibility. Lexical analysis, recursive-descent parsing, SSA-form intermediate representation, and lightweight optimizations are employed, with end-to-end validation performed on single-board computers. Contribution/Results: Experimental evaluation shows the compiler achieves one-third the binary size and 40% lower memory footprint compared to conventional compilers, while retaining functional completeness and optimization quality sufficient for compiler education and embedded prototyping.

Existing LLM orchestration scripts suffer from insufficient modularity and limited parallelization capabilities. To address these issues, this paper proposes an abstract framework grounded in algebraic effects and composable effect handlers, which decouples side effects—such as LLM invocations, I/O operations, and concurrency—into replaceable, composable effect interfaces. This design enforces a strict separation between workflow logic and execution details, preserving code clarity and maintainability while natively enabling fine-grained parallel scheduling and optimization. Evaluated on Tree-of-Thoughts reasoning tasks, the framework achieves a 10× end-to-end performance improvement over baseline approaches. Results demonstrate that the method effectively enhances execution efficiency without compromising modularity, confirming its validity and broad applicability across LLM-driven workflows.

Traditional least fixed-point semantics often fails to support precise static cost analysis due to its neglect of recursive structural information. This work proposes operator semantics as an intermediate representation bridging syntax and denotational semantics, treating programs as operators and constructing a higher-order abstract domain grounded in category theory, with composition as the core primitive. This framework enables abstract compilation that simultaneously achieves soundness, precision, and modularity. The approach supports cost analysis for general functional unknowns and generalized fold-based metrics, leveraging a solver-agnostic technique for extracting optimal recurrence relations. Consequently, it facilitates precise static cost analysis of recursive programs over algebraic data types, encompassing generalized size metrics beyond the reach of conventional methods.

Existing Kronecker adapter architectures predominantly rely on fixed or heuristic designs, and the impact of their component dimensions and counts on model performance remains underexplored. This work presents the first systematic investigation into how component structure critically influences adaptation capability, introducing Configurable Decomposed Kronecker Adapter (CDKA)—a method that enables flexible structural design through parameter-budget-aware component configuration and training stability strategies. Extensive experiments across diverse natural language processing tasks demonstrate that CDKA substantially enhances adaptation performance. The study further provides a reproducible open-source implementation alongside practical deployment guidelines to facilitate broader adoption and future research.

This work addresses the limitations of existing join pattern implementations, which often rely on domain-specific languages and exhibit rigid, inflexible matching algorithms that hinder integration into general-purpose programming ecosystems. To overcome these challenges, we propose and implement JoinActors—a modular and extensible join pattern matching library built on Scala 3. JoinActors is the first library to support join patterns natively within a general-purpose language, offering an intuitive API powered by metaprogramming and incorporating fair join semantics. Its key innovation lies in enabling plug-and-play support for multiple matching algorithms, facilitating direct performance comparisons. Experimental results demonstrate that the new implementation significantly improves performance while preserving matching correctness, thereby providing an efficient coordination mechanism for complex message-passing systems and establishing a reusable experimental platform for future research on join patterns.

This work addresses the inefficiency and lack of guidance faced by front-end developers when manually selecting plausible and natural attribute values for instantiating reusable UI components within a vast design space. To tackle this challenge, the paper introduces the concept of “discriminative variants,” which uniquely integrates symbolic reasoning with large language models (LLMs). Symbolic reasoning identifies visually salient attributes, while the LLM leverages real-world knowledge to generate component instances that balance fidelity to exemplars with meaningful differentiation. This approach shifts the paradigm from ad hoc manual configuration to structured exploration of the design space. A user study (n=12) demonstrates that the generated variants effectively aid developers in comprehending the design space, significantly improving both instantiation efficiency and user experience, while maintaining strong domain relevance.