structure-preserving map construction

Existing approaches lack formal mechanisms for semantically preserving structural transformations across heterogeneous representation systems (e.g., formal languages, geometric diagrams, informal notations), especially for arbitrary user-specified semantic relations such as equivalence. Method: This paper introduces a representation-system-agnostic (RS-agnostic) structural migration calculus framework grounded in formal inference rules and pattern-based encoding. It enables verifiable, semantics-preserving structural mapping and transformation among disparate representation systems by integrating representation-system theory with constructive space modeling. Contributions: (1) The first formally verified RS-agnostic transformation calculus proven to satisfy arbitrary target semantic relations; (2) A pattern-driven, information-preserving mechanism supporting automatic, meaning-preserving reconstruction across multimodal representations; (3) A rigorous formal foundation for cross-representational cognitive modeling and intelligent representation generation. The framework achieves high generality in abstract representation transformation while ensuring semantic fidelity and verifiability.

This paper addresses the lack of systematic support for theory morphisms and logical relations in the $λΠ$-calculus modulo rewriting framework. Methodologically, it introduces a unified extension mechanism that formally integrates both concepts for the first time within this framework and designs a pattern-based invariant verification procedure, reducing the proof of translation invariants to finite, decidable propositional checks. The main contributions are: (1) a structurally clear, machine-verifiable formalization of inductive translations—e.g., type erasure; (2) the first fully verified type-erasure instance in $λΠ$-calculus modulo rewriting; and (3) a reusable methodology for rigorously verifying the correctness of translations between formal systems.

This work addresses the semantic fragmentation and toolchain fragmentation in traditional model-driven engineering, which stem from the lack of a unified formal foundation among models, metamodels, templates, and transformations. To bridge this gap, the paper introduces Model Expression Algebra, treating models as values and expressions as terms, and unifying modeling operations through an evaluation homomorphism. By embedding a domain-specific language (DSL), the approach integrates metamodeling, model construction, and transformation within a single functional algebraic framework—unifying all four aspects for the first time. A type system ensures transformation safety, while free variables represent templates and computational operators encode functional logic, enabling type-preserving evaluation and built-in support for large-model expressions. Experimental results demonstrate that a single language can fulfill the full spectrum of modeling tasks while providing formal guarantees.

This study addresses the formal representation and preservation of logical relationships among nested conditions in graph transformation rules. To overcome the limitations of existing approaches, which lack precise characterization of structural dependencies between nested conditions, the work introduces condition operators that emulate logical connectives and, for the first time, defines structural morphisms between nested conditions. Within a categorical framework, it establishes criteria under which these morphisms align with logical implication and proves that they preserve implication under a specific semantic interpretation. Furthermore, the paper uncovers the functorial nature and universal properties of the proposed constructions, thereby providing novel formal tools to strengthen the logical foundations of graph transformation systems.

Neural network internal representations often lack stability and cross-architectural consistency due to architectural disparities, hindering knowledge transfer and modular deployment. To address this, we propose a structured regularization framework comprising linear shaping operators and rectified path constraints, which explicitly encode inductive biases to improve geometric alignment of representations across architectures. Through theoretical analysis, controlled transfer experiments, and a novel representation alignment metric, we systematically demonstrate that structural priors significantly enhance semantic consistency among heterogeneous models. Our method improves downstream task performance in model distillation and modular learning by up to 12.3%, offering an interpretable and scalable paradigm for building robust, composable deep learning systems.

This work presents the first systematic approach to instance-free schema inference under property graph query transformations. Given a ProGS input schema and a G-CORE query, the authors propose a multi-layer mapping technique that translates property graphs, schemas, and queries into RDF, SHACL, and SPARQL CONSTRUCT representations, respectively, enabling automatic derivation of structural constraints on the output graph via description logic reasoning. By leveraging RDF reification and cross-language semantic bridging, the method establishes a sound and semantically equivalent metatheoretical foundation. This enables generic output schema inference applicable to any input graph conforming to the given schema, while formally verifying both the correctness of the derived constraints and the semantic fidelity of the mappings.

This study addresses the limited semantic transparency and poor comprehensibility of existing conceptual models, which stem from their reliance on low-level syntactic constructs to represent domain abstractions, thereby hindering effective system design and stakeholder communication. To overcome this, the paper proposes a language-agnostic abstract symbol engineering approach that identifies, formalizes, visualizes, and validates recurring syntactic configuration patterns, replacing them with high-level, semantically transparent abstract symbols. The method is instantiated as the DeCleaR extension to Dynamic Condition Response (DCR) graphs. Empirical evaluation demonstrates that DeCleaR significantly enhances perceived model quality, pragmatic quality, and user preference compared to standard DCR graphs.

This work proposes a formalization of algorithms within an intensional computability framework and clarifies their relationship to implementations in computational models. Treating computational models as monoid actions on configuration spaces, programs are modeled as dynamical systems constrained by such actions. Algorithms are defined as finite directed graphs of partial maps over edge-labeled abstract data structures, explicitly separating control flow from data operations. By leveraging tools from category theory, dynamical systems theory, and graph theory, the approach constructs a rigorous semantic framework that, for the first time, treats algorithms as abstract specifications of computational behavior and precisely characterizes the structure-preserving implementation relation between programs and algorithms, thereby deepening our understanding of the nature of computation.

This work addresses the prevailing lack of systematic understanding of foundational formal theories in current AI compiler design, which hinders rigorous evaluation of the completeness and desirability of intermediate representations and compilation abstractions. For the first time, it systematically establishes precise correspondences between core mechanisms of MLIR—such as term rewriting systems, refinement calculi, and abstract interpretation—and classical formal theories. By grounding compiler abstractions in formal semantics, the paper clarifies the theoretical underpinnings of these constructs, articulates a precise notion of “design completeness,” and provides assessable criteria and guiding principles to navigate trade-offs between engineering pragmatism and theoretical ideals.

This work addresses the gap between high-level abstractions and efficient or compatible binary layouts in functional languages, where users lack precise control over the low-level representation of data types. It formalizes layout transformations of finite algebraic data types as isomorphisms in a commutative rig (a ring without additive inverses), leveraging rig equations to characterize data layouts and their conversions. The approach introduces partial isomorphisms to accommodate type embeddings such as bit padding. Grounded in the categorical theory of rig algebras and isomorphisms, this framework uniformly handles both total and partial representation mappings, ensuring correctness and composability of layout transformations within the type system. Consequently, it provides an expressive, verifiable, and efficient mechanism for controlling low-level data representations.