Logic-Parametric Frameworks Overview

• Logic-parametric frameworks are families of logical systems that treat key features—such as syntax, semantics, and proof rules—as configurable parameters.
• They enable systematic instantiation and comparative analysis across various domains, from program verification to quantitative reasoning.
• These frameworks employ design patterns like parametric quantification, algebraic parameterization, and meta-logic composition to enhance modularity and scalability.

A logic-parametric framework is a family of logical systems or methodologies in which certain structural, semantic, or operational features are treated as explicit parameters, rather than being fixed a priori. These frameworks enable the specification, reasoning, and analysis of whole classes of systems, properties, or models whose logical underpinnings vary with parameters such as architectural size, operational rules, time bounds, interaction weights, or even the logic itself. Logic-parametricity provides modularity, scalability, and adaptability across domains spanning program verification, component architectures, temporal property mining, probabilistic reasoning, and meta-logic composition.

1. Conceptual Foundations and Design Principles

The central tenet in logic-parametric frameworks is that some logical ingredient—be it syntax, semantics, proof-calculus, or the logic itself—is not statically fixed, but abstracted as a parameter, enabling systematic instantiation, composition, or comparison between logical systems. These frameworks emerge when:

• The domain of discourse (e.g., component identifiers, time intervals, weights, architectural topology) is unbounded or subject to runtime instantiation.
• Fundamental logic constructs (e.g., truth-values, program modalities, probability constraints) depend on parameters such as algebraic structures, operational rules, or quantitative thresholds.
• There is a need to uniformly reason about entire classes of systems (e.g., parametric architectures, families of temporal properties, or systems with variable numbers of components) without reifying each individual instance.
• Logical connectives, modalities, or semantic clauses can themselves be parameterized to capture a spectrum from classical to multi-valued, qualitative to quantitative, or static to dynamic logics.

Notable logic-parametric design patterns include:

• Parametric quantification: Systematically varying over unbounded sets (e.g., component instances (Bozga et al., 2019), variable number of traces, time bounds).
• Algebraic parameterization: Making the algebraic semantics of the logic (e.g., residuated lattices, commutative semirings, skew-fields) a parameter (Gomes, 2019, Pittou et al., 2019).
• Language- and logic-parametricity: Embedding formally different logical systems as plug-in modules, often through meta-level frameworks (Farjami et al., 9 Jan 2026, Dasseville et al., 2015, Bjorndahl et al., 2017).
• Structural parameterization: Systematically constructing parameterized logical proofs, proof rules, or templates (Bozga et al., 2019, Dasseville et al., 2015).

2. Logic-Parametric Frameworks for System Architectures

Logic-parametricity plays a critical role in specifying and reasoning about parametric component-based architectures and their quantitative generalizations:

Parametric Local Reasoning with Separation Logics

The logic described in (Bozga et al., 2019) introduces a resource-logic framework where:

• The set of active components $C$ is parameteric and only bounded but never fixed.
• Formulas involve separation ($*$) over sub-architectures, and support modalities for dynamic reconfiguration actions (adding, removing, connecting, migrating components).
• Local reasoning is enforced: Proofs scale independently of $|C|$ due to the frame rule, which allows reasoning about local changes modularly. The frame rule formally reads

$$\frac{\,\{\varphi\}\,\alpha\,\{\psi\}\,}{\{\varphi*R\}\,\alpha\,\{\psi*R\}} \qquad \mathrm{mods}(\alpha)\cap\mathrm{fv}(R)=\emptyset$$

• Decision procedures enjoy the small-model property, with validity decidable in NP relative to the formula and heap size, leveraging reduction to SMT over uninterpreted functions and Presburger arithmetic.

Parametric Weighted Component Architectures

In (Pittou et al., 2019), a weighted first-order extended interaction logic (wFOEIL) parameterized by a commutative semiring $K$ is introduced. The logic enables:

• Encoding of parametric quantitative architectures, where the parameter is the number of instances of each component type.
• Logical formulas and quantifiers systematically enumerate over possible component instances.
• Built-in weighted sum/product, Cauchy, and shuffle operators, and their quantified extensions ($\sum$, $\prod$, $\odot$, $\varpi$).
• Decidability of equivalence for formulas over subsemirings of skew fields, via reduction to equivalence of weighted finite automata.
• Standard qualitative and quantitative architectural styles (master/slave, pipes/filters, blackboard, publish/subscribe) are all expressed as instances.

3. Temporal, Dynamic, and Probabilistic Logic-Parametricity

Parametric and Weighted Temporal Logics

• Parametric Linear Dynamic Logic (PLDL) (Faymonville et al., 2014, Faymonville et al., 2015): Extends LDL by equipping modalities with variable time-bounds. The logic is parameterized by variables $x$, allowing bounded temporal operators $*$0. PLDL strictly generalizes parametric LTL, PROMPT-LTL, and LDL, admitting ω-regular specifications and parametric timing constraints. Model checking is PSPACE-complete; realizability is 2EXPTIME-complete, with tight parameter bounds and automata-theoretic reductions.
• Parametric Interval Temporal Logic (PHS) (Bozzelli et al., 2022): Interval logics parameterized by upward and downward bounds on interval durations. Satisfiability and model-checking remain decidable (EXPSPACE-complete for core fragments), and PHS strictly subsumes parametric LTL in expressiveness.

Parametric Temporal Logic Property Mining

Property mining frameworks treat logical parameters (thresholds in atomic propositions or temporal intervals) as variables to be synthesized via robustness-guided stochastic optimization. Robust semantics quantify the degree of property satisfaction, enabling Pareto-front optimization over parameter spaces (Hoxha et al., 2015). The solution space is typically highly non-convex, but parameter mining supports visualization, sound falsification, and parameter synthesis for high-dimensional hybrid system models.

Parametric Probability Logic

Parametric embedding of logical formulas into probabilistic graphical models allows the derivation of logical entailments as optimization (min/max) tasks on real-variable parameters, unifying categorical logic with parametric probability (Norman, 2012, Norman, 2013). This fully generalizes Boolean logic—each logical clause becomes a parametric constraint, and all deduction reduces to (linear) programming.

4. Meta-Logical and Algebraic Frameworks

Many-Valued and Algebraic Logic-Parametricity

Frameworks such as multi-valued concurrent dynamic logic (Gomes, 2019) treat the action lattice $*$1 (e.g., a complete residuated lattice, cost semiring, fuzzy chain) as a parameter, generating whole families of weighted, many-valued, or quantitative logics from a single syntactic and semantic skeleton. By varying $*$2, one systematically recovers or generalizes from classical PDL to fuzzy, probabilistic, or cost-aware logics.

Compositional Meta-Logic and Template Programming

Generalized frameworks (Dasseville et al., 2015) specify logics as modular compositions of "logic constructs," each specified by a syntactic and semantic inductive rule:

• The logic is parameterized over which language constructs (connectives, inductive definitions, templates, quantifiers) are included.
• Compositionally combining constructs yields nested higher-order, inductive, or template-augmented logics at the meta-level.
• Semantic correctness guarantees are carried by stratified rule composition; descriptive complexity is preserved, and macro expansion is justified via equivalence theorems.

2-Categorical and Diagrammatic Parametricity

The diagrammatic logic framework (0908.3737) formalizes logic-parametricity in the language of adjunctions, categories of fractions, and 2-categories. Here:

• Whole logics, their morphisms, and 2-morphisms (e.g., parameterization, parameter passing) are categorical objects, and parameterized logics are constructed by functorial passage through morphisms at the meta-level.
• Parameterization (e.g., adding a formal parameter $*$3 to all non-pure operations) and parameter passing (instantiating $*$4 to an argument $*$5) are encoded as 1- and 2-cells in the logic 2-category, supporting compositional and modular logic specification building.

5. Logic-Parametricity in Neuro-Symbolic AI and Language

A contemporary dimension is seen in frameworks for neuro-symbolic reasoning, in which the "meta-logic" is a first-class, controllable parameter in the system architecture (Farjami et al., 9 Jan 2026). The benefits include:

• Modularity: Logical formalisms (FOL, deontic, modal, conditional logics) are software modules, embedded via shallow semantic translation (e.g., into higher-order logic).
• Adaptivity: The choice of logic is dynamically selected per reasoning task, supporting domain-specific inference (e.g., FOL for object-level, KD or DDL_CJ for ethical reasoning).
• Verifiability: All reasoning is checked in a verifier/proof assistant (e.g., Isabelle/HOL), independent of LLM or heuristics.
• Quantitative performance: Logic-internal strategies (native modal/deontic reasoning) outperform logic-external (axiomatized) ones in complex domains.

Empirical studies demonstrate domain-sensitive behavior and trade-offs: expressivity, verifiability, proof efficiency, and syntactic robustness depend on the chosen logic parameter.

6. Expressiveness, Decidability, and Optimization in Logic-Parametric Frameworks

A salient feature of logic-parametric frameworks is systematic trade-off analysis and algorithm design across the spectrum of logic parameters:

• By varying language parameters (modalities, quantifiers, weights), expressiveness can be increased (e.g., adding regular or pushdown language parameters in temporal logics (Gutsfeld et al., 2019)).
• Decidability and complexity results are precisely characterized as functions of logic parameters (e.g., model checking for CTL[REG] is EXPTIME-complete, but becomes undecidable for DCFL parameter classes).
• Optimization over parameters (e.g., minimal satisfaction bounds in temporal logics, optimal weights in architecture logics) is tightly linked with best-known computational complexity for the associated parameterized logic, often preserving (or minimally extending) the classical lower and upper bounds across full parametric families (Faymonville et al., 2014, Faymonville et al., 2015).
• Key completeness and correctness theorems (e.g., the frame rule, cyclic preproof soundness, macro expansion equivalence, universal type space theorems) are all stated uniformly over the logic parameters.

7. Illustrative Examples and Families

Numerous case studies exemplify the utility and generality of logic-parametric frameworks:

Domain/Framework	Logic Parameter	Example/Role
Separation logic for parametric architectures	Number of components	Parametric pipeline verification (Bozga et al., 2019)
Parametric weighted architectures	Semiring of weights, inst counts	Master/slave, pipes/filters w/ quantitative costs (Pittou et al., 2019)
Parametric linear dynamic logic (PLDL)	Parameter set for bounds	Prompt response within $*$6 steps, even-position constraints (Faymonville et al., 2014)
Multi-valued concurrent PDL (CGDL($*$7))	Action lattice $*$8	Boolean, fuzzy, Łukasiewicz, tropical/cost logics (Gomes, 2019)
Diagrammatic logic 2-category	Logic morphisms, parameters	Parameterization and exact parameter passing (0908.3737)
Template-based logic design	Logic constructs, macro families	Stratified template and macro expansion (Dasseville et al., 2015)
Probabilistic logic inference	Family of conditional constraints	Syllogistic deduction via parametric optimization (Norman, 2012, Norman, 2013)
Logic choice in neuro-symbolic NLI	Logic $*$9	FOL, KD, DDL_CJ, automated logic selection (Farjami et al., 9 Jan 2026)
Temporal logic mining in CPS	Specification parameters	Mining falsification Pareto fronts (Hoxha et al., 2015)

These examples illustrate how logic-parametric approaches systematically separate structure, semantics, and proof principles from transient instantiation, enabling scalable, modular, and expressive reasoning in modern formal and computational logic.