MPLang: Declarative GNNs & Language Ensembles

Updated 29 December 2025

MPLang is a multi-faceted framework encompassing a formal declarative language for message-passing neural networks with precise semantics.
It establishes expressive equivalence between MPLang expressions and traditional MPNNs, enabling simulation through ReLU activations and range-shifted mergers.
It also extends to multi-language ML ensembles and template-driven natural programming, offering practical benefits in code generation and probabilistic programming.

MPLang is a term with multiple precise meanings in contemporary computational research, ranging from a formal declarative language for message-passing neural networks (GNNs), to ensemble and multi-language machine learning frameworks, to template-driven natural programming languages for educational and accessibility purposes. Each instantiation reflects distinct design choices, mathematical foundations, and application domains. This article systematically surveys the principal definitions and research trajectories of MPLang, emphasizing the formal message-passing language that characterizes the expressive power of GNNs (Geerts et al., 2022), while contextualizing emerging ensemble (multi-programming-language) frameworks and natural code generation paradigms.

1. MPLang as a Declarative Message-Passing Language

The foundational use of MPLang is as a formal language for expressing the computations performed in message-passing neural networks (MPNNs). Let $G = (V, E)$ be a finite undirected graph ( $E$ symmetric, irreflexive), with node feature maps $\chi : V \to \mathbb{R}^d$ . An MPLang expression denotes a global feature-map transformer (GFMT), mapping each $(G, \chi)$ to an $\mathbb{R}^r$ -valued feature map.

Syntax (BNF):

$\begin{array}{rcl} \langle\mathit{expr}\rangle &::=& 1 \mid P_{i}\ (1\le i\le d) \mid a\langle\mathit{expr}\rangle \mid \langle\mathit{expr}_1\rangle+\langle\mathit{expr}_2\rangle \ &&\mid f\left(\langle\mathit{expr}\rangle\right) \mid \Diamond\langle\mathit{expr}\rangle \end{array}$

$1$: scalar constant; $P_i$ : projection of $i$ -th coordinate; $a \in \mathbb{R}$ : scalar multiplication; $+$ : addition; $f$ : continuous activation function (unrestricted, or set to specific $\sigma$ ); $\Diamond$ : neighborhood summation.

Denotational semantics:

Given $e$ of arity $d$ ,

$e(G)(\chi)(v) = \begin{cases} 1 & e = 1 \ \chi(v)_i & e = P_i \ a \cdot e_1(G)(\chi)(v) & e = a \cdot e_1 \ e_1(G)(\chi)(v) + e_2(G)(\chi)(v) & e = e_1 + e_2 \ f\left(e_1(G)(\chi)(v)\right) & e = f(e_1) \ \sum_{u \in N_G(v)} e_1(G)(\chi)(u) & e = \Diamond e_1 \end{cases}$

Tupling scalar expressions yields vector-valued GFMTs (Geerts et al., 2022).

Example Expressions:

Feature averaging: $e = (P_1 + P_2) / 2$
Two-hop neighbor sum: $e = \Diamond(\Diamond P_1)$

2. Expressive Power: Equivalence and Encodings

Every traditional $\sigma$ -MPNN can be encoded as an MPLang expression by unrolling each affine and aggregation operation compositionally. The converse—in which arbitrary (ReLU-)MPLang expressions are realized by standard MPNNs—holds under specific activation assumptions:

Exact Simulation with ReLU: Every function defined by a $\mathrm{ReLU}$ -MPLang expression can be implemented by a $\mathrm{ReLU}$ -MPNN via a block-matrix and parallel composition construction, using identities such as $x = \mathrm{ReLU}(x) - \mathrm{ReLU}(-x)$ (Geerts et al., 2022).
Arbitrary Activation, Bounded Degree/Domains: For graphs of degree $\leq p$ and bounded input features, every arbitrary-activation MPLang expression can be compiled into an MPNN with possibly varying activations per layer, leveraging range-shifted mergers into a single activation (Geerts et al., 2022).
ReLU Approximation: For compact $X \subset \mathbb{R}^d$ , every MPLang expression is uniformly approximable (to error $\epsilon$ ) by a ReLU-MPNN using the universal approximation property (Geerts et al., 2022).

These results delimit the circumstances in which "MPNNs = MPLang," clarifying when message-passing expressiveness is fundamentally constrained by the choice of activation function and architectural closure properties.

3. Mathematical Structure: A-MPLang and Logical Characterization

A-MPLang denotes the affine (activation-free) fragment of MPLang, which is analytically characterized in terms of walk-summed features and walk-counts on the input graph (Barceló et al., 22 Dec 2025).

Normal-form theorem: Any A-MPLang expression of $\Diamond$ -depth $n$ is given by

$e(G, \gamma)(v) = \sum_{i=0}^n \left( c_i \Diamond^i 1 + \sum_{j=1}^d c_{i,j} \Diamond^i P_j \right)(G, \gamma)(v)$

where $\Diamond^i$ denotes $i$ -fold neighborhood aggregation (walks of length $i$ ).

On colored graphs, rational fragments with bounded input domains and eventually constant activations (e.g., $\mathrm{sign}, \mathrm{bool}, \mathrm{TrReLU}$ ) all have identical expressive power for Boolean and numerical queries (Barceló et al., 22 Dec 2025). However, genuine unbounded activations (ReLU) are strictly more expressive when combined with linear layers, as witnessed by queries such as $\max\{0, \#$ red neighbors $- \#$ blue neighbors $\}$ .

This logical analysis situates MPLang as a canonical fragment for the formal study of GNN computation, encompassing both its limitations (lack of closure under Boolean operations without non-linearities) and its superiority over prior modal counting logics in the presence of ReLU (Barceló et al., 22 Dec 2025).

4. MPLang in Multi-Programming-Language Machine Learning

MPLang also appears in the literature as an abbreviation for "Multi-Programming-Language" ensemble or modeling frameworks. These systems exploit the diversity of code styles or model behaviors across distinct programming languages using LLMs.

Multi-Programming Language Ensemble: Treats code generation in each language $\ell \in L$ as a weak expert, ensembles outputs using mixture-of-experts or voting/union aggregation, and leverages orthogonal error modes among languages to improve pass@ $k$ performance. Mathematical formalization involves ensemble distributions: $P_{\mathrm{ens}}(y|x) = \sum_{\ell \in L} w_\ell P_{\ell}(y|x),\quad \sum_\ell w_\ell = 1,\; w_\ell \ge 0$ Ensemble scoring combines model score and a validation reward (Xue et al., 6 Sep 2024).

Algorithmic techniques include:

Reflection (self-correction loops for non-passing candidates)
Integration with Monte Carlo Tree Search (MCTS) for diverse search trajectories

Empirically, such multi-language ensembles achieve state-of-the-art code generation accuracy, with documented improvements of up to $+17.92\%$ pass@1 on HumanEval (Xue et al., 6 Sep 2024).

5. Multi-Language-Driven IE and Template-Based Natural Programming

Multi-language code representations—distinct from multilingual natural language—are leveraged in information extraction (IE) and synthetic programming environments:

Information Extraction (IE) Frameworks: Encoding each IE instance as code in a variety of programming languages (e.g., Python, C++, Java), then aggregating LLM predictions. Empirically, such PL diversity yields micro-F1 gains (up to $+1.7$ absolute over best Python-only systems), especially on non-NER tasks where syntactic biases across languages yield complementary results (2505.16107).
Template-Driven Natural Programming: MyProLang (sometimes denoted MPLang) is a natural-language-like imperative language generated via GUI templates and string-filled NLG, compiled to C#, targeting accessibility and error-mitigation. The entire system is formalized with EBNF grammar and a four-stage compilation pipeline, emphasizing usability and automation rather than expressiveness (Bassil et al., 2012).

6. Distinctions, Limitations, and Theoretical Implications

The name "MPLang" spans multiple technical foundations. In the context of GNN expressiveness:

Limitations: Exact expressive equivalence between MPLang and MPNNs generally requires ReLU or piecewise linear activations and may break on unbounded-degree graphs or domains. Some primitives (e.g., max-pooling, unless via the ReLU-trick) do not have a direct expression-level encoding but remain implementable at network level (Geerts et al., 2022).
Expressiveness Separation: ReLU-MPLang (unbounded activations) is strictly stronger than MPLang with only eventually constant activations, both numerically and at the level of definable Boolean queries (Barceló et al., 22 Dec 2025).
Logical Closure: The affine fragment (A-MPLang) fails to capture even standard modal logic (lack of closure under conjunction/diamond), while MPLang with sufficiently rich non-linearity subsumes and goes beyond weighted modal logics studied in descriptive complexity (Barceló et al., 22 Dec 2025).

For multi-language LLM frameworks, the diversity of programming-language prompts or expert modules leads to quantifiable error reduction via variance minimization and is particularly impactful for low-resource languages.

7. Connections to Software Engineering and Multi-Language Development

Separate from theory-oriented uses, MPLang also refers to practical issues in software engineering:

Multi-Programming-Language Commits (MPLC): Commits that touch files in multiple programming languages exhibit higher change complexity, longer issue resolution times (up to $+124.7\%$ ), and higher defect density in affected files (Li et al., 2021).
Framework Support: Recent LLM architectures adopt specialized mixture-of-language-expert modules, with LoRA-based adapters, to optimize for parameter efficiency and low-resource language lift when scaling codebases across multiple languages. Modular adapter architectures facilitate dynamic or plugin-style language extension (Zong et al., 18 Jun 2025).
Probabilistic Programming: Multi-language probabilistic programming environments (e.g., MultiPPL) allow explicit embedding and switching between sub-languages (exact for discrete, approximate for continuous), with formal guarantees on inference correctness and empirical benefits in scalability and accuracy (Stites et al., 26 Feb 2025).

In summary, MPLang encompasses a spectrum: (1) a formal calculus for analyzing the theoretical capacity of message-passing neural architectures (Geerts et al., 2022, Barceló et al., 22 Dec 2025), (2) a design pattern for robust multi-language code generation and information extraction with LLMs (Xue et al., 6 Sep 2024, 2505.16107), (3) a template-driven natural programming interface (Bassil et al., 2012), and (4) a software engineering construct for understanding the risks and complexity of multi-language codebases (Li et al., 2021), as well as (5) a foundation for interoperable probabilistic programming (Stites et al., 26 Feb 2025). The unifying theme is programmability and expressiveness across potentially heterogeneous languages—be it in graph computation logic, code synthesis, or programming system integration—subject to formal expressiveness guarantees and with demonstrated practical benefit across both theory and systems research.