discover relational concepts

In sparse-reward settings, agents struggle to autonomously discover and exploit task-relevant, structured inter-object relationships for learning generalizable relational policies. Method: We propose a novel Relational Reinforcement Learning (RRL) framework that tightly integrates symbolic function approximators with RRL, enabling joint, incremental selection of relational representations and co-evolution of policies. Using Atari environments (Breakout, Pong, Demon Attack), we design relation-aware state encoding and policy learning mechanisms—without handcrafted relational priors. Contribution/Results: The agent automatically identifies task-critical relations and achieves performance on par with strong baselines. Crucially, the learned relational representations exhibit cross-task transferability, supporting zero-shot adaptation to new tasks. This provides an interpretable, generalizable modeling pathway toward human-like, structure-aware decision-making—marking the first work to unify symbolic function approximation with RRL for emergent relational abstraction.

This work addresses the challenges posed by the rise of AI-generated queries to the readability and structural explicitness of existing relational query languages. It proposes a unified framework based on Abstract Relational Calculus (ARC) and relational graphs to systematically compare how languages such as SQL, dataframes, and graph query notations express identical query intents. By introducing a formal terminology encompassing information needs, query mappings, and relational schema structures, the study for the first time brings classical database languages and emerging alternatives into a common analytical perspective. The framework is further extended to handle recursive queries, nested relations, and problems beyond PTIME. This contribution establishes a reusable language comparison methodology and a precise design lexicon, offering practical tools for evaluating and designing future relational query languages.

This work addresses program synthesis by proposing a general relational decomposition framework: input-output examples are encoded as sets of logical facts, and the mapping between them is explicitly modeled as a logical relation. Methodologically, it formalizes program synthesis as a relational subtask decomposition problem—marking the first such formulation—and leverages inductive logic programming (ILP) for interpretable, model-agnostic relation learning and inference. Crucially, no domain-specific architecture or task customization is required, enabling cross-task generalization. Evaluated on four challenging benchmarks, the approach significantly outperforms standard sequence- and tree-based neural models. Moreover, by interfacing with off-the-shelf ILP solvers, it surpasses state-of-the-art domain-specific synthesizers across multiple benchmarks. The contribution is a novel, interpretable, modular, and model-independent paradigm for program synthesis grounded in relational logic and ILP.

First-order logic with at most three variables (FO₃) is semantically expressive but cannot be directly processed by reasoning tools supporting only relational algebra (RA), which lack native FO₃ support. Method: We present the first sound, mechanically verifiable translation from FO₃ to RA. Our lightweight tool—built on Z3 and Python—compiles FO₃ formulas into semantically equivalent RA expressions and uses Z3 to formally verify correctness throughout the translation process. Contribution/Results: This work establishes the first formal, machine-checkable semantic bridge between FO₃ and RA. It demonstrates that FO₃ can serve as a high-level input language for RA-based reasoning systems, eliminating the need for users to manually encode logical specifications in low-level RA. Empirically, it significantly lowers cognitive and operational barriers for end users, enabling more accessible and reliable automated reasoning over relational data. The translation is complete for FO₃, preserves logical equivalence under standard interpretations, and supports verification via SMT-based proof checking.

This paper addresses the challenge in robotic task planning where world models struggle to simultaneously achieve interpretability, generalization, and task-oriented abstraction. We propose a neuro-symbolic predicate-driven abstract world model. Methodologically, we introduce the first neuro-symbolic predicate language supporting *online predicate invention*, and design an end-to-end differentiable neuro-symbolic integration architecture that enables semantic compression of perception-action spaces and task-driven abstraction, jointly learning the abstract model and predicate representations. Our contributions are threefold: (1) the first integration of online predicate invention into world model learning; (2) a unified framework reconciling symbolic interpretability with neural representation generalization; and (3) significant improvements in sample efficiency, out-of-distribution generalization, and decision interpretability across five simulated robotic tasks—outperforming hierarchical reinforcement learning, vision-language model–based planning, and purely symbolic approaches.

Traditional relational algebra suffers from limited semantic expressiveness and inadequate support for physical abstraction in modern database systems. This work systematically introduces Tarski’s relation algebra (TAR)—a formalism predating Codd’s relational model by over a century—into the database field for the first time, leveraging it as the theoretical foundation for designing and implementing a novel query language named Prela. Prela emphasizes compositional design and execution controllability, substantially enhancing query conciseness, readability, and runtime efficiency. The implementation demonstrates that TAR not only serves as a viable theoretical basis for next-generation database systems but also offers tangible practical advantages over conventional approaches.

Existing approaches suffer from a formal disconnect between program structural knowledge and behavioral knowledge, limiting the integration of domain semantics into executable code. Method: This paper proposes Semantic Lifting—a novel technique that enables dynamic, type-safe mapping of object-oriented program runtime states to knowledge graphs directly at the programming language level. Implemented in the SMOL language, it introduces an embedded semantic reflection layer unifying ontology modeling, static typing, and runtime program analysis. Contribution/Results: The approach natively supports domain knowledge representation, real-time semantic querying, and virtualized intervention, bridging the formal gap between system structure and behavior—extending reflection beyond syntactic constructs. An open-source implementation and a geological modeling case study demonstrate guaranteed query type safety and substantial improvements in both expressivity and operability of domain knowledge within programs.

Real-world modeling demands abstraction that simultaneously simplifies representations and preserves essential properties under incomplete information—a longstanding challenge in formal methods. Method: This paper introduces a novel logical abstraction framework grounded in both necessity and sufficiency conditions—departing from conventional necessity-only approaches. It formally defines approximate abstractions and their tightest forms, enabling multi-level, composable hierarchical abstraction structures. Built upon classical logic, the framework unifies abstraction mappings, logical reasoning, and computational complexity analysis within a single formal system. Results: The framework significantly improves abstraction fidelity while providing tight complexity characterizations for core reasoning tasks. It establishes a unified theoretical foundation for both exact and approximate abstraction, advancing the state of the art in abstraction-based verification and synthesis.

This work addresses the lack of a systematic investigation into the formal relationship between effect systems and abstract interpretation, particularly whether they can be unified in general settings. It establishes, for the first time, a formal correspondence between the two within a generic framework by embedding effect quantales into abstract domains and formulating a novel perspective on abstract interpretation grounded in events rather than states or values. Drawing upon effect quantale theory, the abstract interpretation framework, and program semantics, the paper successfully reduces effect systems to an instance of abstract interpretation. This reduction not only clarifies the semantic foundations of effect systems but also provides a unified theoretical basis for effect-driven static analysis tools.