Met: F-style Core Calculus for Multimodal Systems

• Met is a rigorous F-style core calculus that underpins multimodal type theory and multi-staged metaprogramming with polymorphism.
• It integrates dependent types, modal operators, and advanced constructs like normalization and decidable type checking to ensure robust type safety.
• The system supports open-code pattern matching and staged computation, forming the backbone for modern polymorphic metaprogramming languages.

The Multimodal System F-style Core Calculus, denoted Met, is a formal system that serves as the foundation for multimodal type theory and multi-staged metaprogramming with polymorphism. It is parameterized by a strict 2-category of modes and supports the construction and analysis of code involving dependent types, modalities, and pattern matching on open polymorphic code. Met accommodates advanced features such as dependent products and sums, universes, intensional identity types, and modal operators, while guaranteeing properties like normalization, decidable type checking, and injectivity of type constructors (Gratzer, 2021, Jang et al., 2021).

1. Modes, Contexts, and Abstract Syntax

Met is built upon a mode theory formalized as a strict 2-category $\Mode$ whose objects are modes ($m, n, o$), 1-cells are modalities ($\mu: n \to m$), and 2-cells ($\alpha: \nu \Rightarrow \mu$) provide coherence substitutions. Contexts $\Gamma$ are parameterized by a mode, with formation rules distinguishing between empty contexts $(\cdot \ctx_m)$, locked contexts $(\LockCx{\Gamma}{\mu} \ctx_m)$, and context extension $(\ECx{\Gamma}{A}<\mu> \ctx_m)$. Types include the dependent products ($\Pi_{x:A} B$), dependent sums ($\Sigma_{x:A}B$), booleans $m, n, o$0, a cumulative universe $m, n, o$1, intensional identity types ($m, n, o$2), and modal types ($m, n, o$3) which transfer types across modes.

Terms incorporate standard lambda calculus constructs with additional modal introduction forms $m, n, o$4 and elimination $m, n, o$5 aligned to the modal structure of the system. The syntax is sufficiently rich to express open code with polymorphic dependencies and manipulable quotations, essential for advanced metaprogramming tasks (Gratzer, 2021, Jang et al., 2021).

2. Declarative Typing and Equality Judgments

Typing in Met is formulated via four principal judgments, all annotated by modes:

• Context formation: $m, n, o$6
• Type formation: $m, n, o$7
• Term formation: $m, n, o$8
• Type and term equality: $m, n, o$9, $\mu: n \to m$0

Type formers are governed by their respective introduction and elimination rules, e.g., dependent products and sums require context extension, while modal types $\mu: n \to m$1 utilize locked contexts. Universe codes are introduced with definitional isomorphisms ($\mu: n \to m$2) and modal types commute with universes.

Modalities are equipped with functoriality and coherence equations reflecting the 2-cell structure and guarantee correct inter-mode transport of variables and values. The system is structured to statically ensure correct relationships between terms, their contexts, and corresponding modes (Gratzer, 2021).

3. Judgmental Equality, Beta Laws, and Commuting Conversions

Each type constructor in Met is endowed with corresponding $\mu: n \to m$3-reduction and, for positive types, $\mu: n \to m$4-expansion rules:

• $\mu: n \to m$5, $\mu: n \to m$6 types admit both $\mu: n \to m$7 and $\mu: n \to m$8; e.g. $\mu: n \to m$9, $\alpha: \nu \Rightarrow \mu$0.
• $\alpha: \nu \Rightarrow \mu$1 supports classical recursion equations.
• Intensional identity has its $\alpha: \nu \Rightarrow \mu$2 rule, e.g., $\alpha: \nu \Rightarrow \mu$3.
• Modal types $\alpha: \nu \Rightarrow \mu$4 have only the $\alpha: \nu \Rightarrow \mu$5 rule, such as $\alpha: \nu \Rightarrow \mu$6; no $\alpha: \nu \Rightarrow \mu$7-law applies.

Commuting conversions (ψ-rules) systematically guarantee compatibility of nested eliminations, such as pushing a modal let-construction through projections or conditionals. Structural rules (reflexivity, symmetry, congruence) complete the definitional equality infrastructure, reducing the conversion problem to syntactic equality of unique normal forms (Gratzer, 2021).

4. Normalization and Synthetic Tait Computability

Normalization in Met states that every well-typed term (and type) admits a unique normal form up to definitional equality:

• Each $\alpha: \nu \Rightarrow \mu$8 and $\alpha: \nu \Rightarrow \mu$9 has a unique normal form $\Gamma$0 and $\Gamma$1, with $\Gamma$2, $\Gamma$3.

The proof leverages Synthetic Tait Computability: isolating the subcategory of renaming substitutions ($\Gamma$4), constructing presheaf topoi, and gluing along the nerve functor to form a normalization model of Met. This model, internal to the glued topos, encodes open/closed modalities and the relationship between neutral terms, normal forms, and all terms via computability predicates and reflection/reification operations.

The normalization function $\Gamma$5 from syntax to normal forms is established through the universal property of the syntactic Met-cosmos, ensuring the uniqueness and definitional stability of normalized representatives (Gratzer, 2021).

5. Decidability and Injectivity Corollaries

Normalization yields two significant corollaries:

• Decidable conversion and type checking: Since reduction to normal forms is terminating and those forms are unique, a terminating algorithm suffices for checking definitional equality. With decidable equality in the mode theory, type checking for Met is also decidable (Gratzer, 2021).
• Injectivity of type constructors: Normalization ensures that, for example, equality of two dependent products implies equality of their domains and codomains; i.e., $\Gamma$6 implies $\Gamma$7 and $\Gamma$8 (and similarly for other positive types and modal codes).

These results underpin robust type-safe manipulation and meta-theoretic properties of systems built upon Met.

6. Role in Multistage Metaprogramming and Pattern Matching

The Met calculus is foundational for advances in metaprogramming languages, such as Moebius, which instrumentalize its modal and polymorphic capabilities. It supports:

• System F-style polymorphic code generation (with $\Gamma$9-introduction and elimination).
• Multi-level quotation and unquotation, tracking open code and contexts at multiple stages or modal levels.
• Intensional pattern matching on open, polymorphic code, with constraint generation and refinement of polymorphic type variables via unification. This allows code to be constructed, analyzed, and deconstructed generically, critical for metaprogramming scenarios.

Decidable unification in the higher-order pattern fragment enables tractable type inference and constraint solving for code templates and open terms, with soundness and subject reduction properties holding across all operations (Jang et al., 2021).

7. Metatheoretic Properties and Impact

Met enjoys foundational metatheoretic properties such as subject reduction, substitution lemmas (for terms, types, and simultaneous substitutions), and unification soundness. The formalism provides a general, type-theoretic foundation for multi-stage metaprogramming and the manipulation of open code templates, meeting both program generation and code analysis requirements in a strongly-typed setting (Jang et al., 2021).

Through its integration of mode theory, normalization, and modal-dependent types, Met delivers a structurally robust and semantically coherent infrastructure for both theoretical exploration and concrete implementation of modern polymorphic, staged, and modal programming languages. Its results on decidability and injectivity position it as a critical foundation for subsequent developments in multimodal type systems and metaprogramming frameworks (Gratzer, 2021, Jang et al., 2021).