Algorithmic Homomorphism Testing

• Algorithmic homomorphism testing is the study of designing algorithms to decide, count, and test mappings that preserve structure in graphs and algebraic systems.
• It employs techniques such as dynamic programming, parameterized algorithms, and property testing to address decision, counting, and indistinguishability problems.
• The field unifies perspectives from complexity theory, logic, and algebra with applications in CSPs, database theory, and machine learning to solve practical challenges.

Algorithmic homomorphism testing is a field that investigates the design and analysis of algorithms for recognizing, verifying, and counting homomorphisms between discrete mathematical structures, especially graphs, relational structures, and algebraic objects. Homomorphism testing lies at the intersection of algorithms, complexity, logic, algebra, and applications in constraint satisfaction, database theory, statistical physics, group theory, and learning. It encompasses both decision (existence), search, counting, property testing, and reconstructibility problems, and is deeply connected to the theory of equivalence relations, combinatorial width parameters, and the use of algebraic invariants.

1. Homomorphism Testing: Definitions and Frameworks

The central object of paper is a homomorphism between two structures, typically graphs or relational structures. For graphs, a homomorphism from $G$ to $H$ is a mapping $\sigma: V(G) \to V(H)$ such that adjacency is preserved: if $uv \in E(G)$ then $\sigma(u)\sigma(v) \in E(H)$. This notion generalizes many concepts, e.g., graph coloring, list coloring, CSPs, and covers.

Several foundational algorithmic questions are considered:

• Decision problems: Does a homomorphism exist from $G$ to $H$?
• Counting problems: How many such homomorphisms exist?
• Testing problems: Given oracle access to a function, is it a homomorphism or far from any homomorphism?
• Reconstruction/Indistinguishability: Given a vector of homomorphism counts from a family $\mathcal{F}$ to $G$, does $G$ (or a structure with the same counts) exist? Are two graphs homomorphism-indistinguishable over $\mathcal{F}$?

A profound organizing principle is that many tasks reduce to manipulations of homomorphism count vectors $\left( \hom(F, G) \right)_{F \in \mathcal{F}}$, which, by variants of the Lovász Isomorphism Theorem, can fully capture isomorphism type if $\mathcal{F}$ is sufficiently rich (Chen et al., 2021, Cate et al., 2023).

2. Structural Classification and Dichotomy Results

The computational complexity of algorithmic homomorphism testing is sharply characterized in many settings by algebraic and combinatorial parameters:

• Dichotomy for Counting Homomorphisms and Partition Functions: For evaluating $$Z_A(G)=\sum_{\sigma:V(G)\to[n]} \prod_{uv \in E(G)} A_{\sigma(u),\sigma(v)}$$ for fixed symmetric nonnegative $A$, the Bulatov–Grohe dichotomy (Grohe et al., 2011) shows that $Z_A$ is polynomial-time computable if every component of $A$ is rank-1 (up to bipartition), and #P-hard otherwise. This unifies many invariants, from independent sets to partition functions in statistical physics.
• List Homomorphism Testing Trichotomy: For the oracle testing problem of list $H$-homomorphisms, a trichotomy is proven: constant query testing iff $H$ is a reflexive complete or irreflexive complete bipartite graph; sublinear query testing iff $H$ is a bi-arc graph; and otherwise, linear query complexity is necessary (Yoshida, 2011). Sublinear testability aligns with tractability in the classical decision sense.
• Fixed Target Homomorphism Dichotomy: For directed graphs, if the fixed target digraph $H$ admits a weak near-unanimity (weak NU) polymorphism — an operation $\phi$ satisfying $\phi(a,...,b,...,a)=\phi(b,a,...,a,...,a)=...$ — then the decision problem is polynomial-time solvable; otherwise, it is NP-complete. This completes the CSP dichotomy for digraphs (Feder et al., 2017, Feder et al., 2020).
• Maltsev Polymorphisms: When the polymorphism admits identities $h(x,x,y) = h(y,x,x) = x$ (Maltsev), efficient algorithms for the list homomorphism problem exist, and the presence of forbidden substructures can be characterized precisely (Kinne et al., 2020).

3. Algorithms: Exact, Randomized, and Self-Testing

Dynamic Programming and Parameterized Algorithms

• Exact Algorithms Parameterized by Bandwidth/Treewidth: For general (respectively, locally injective) homomorphism problems, algorithms exist in time $O^*((bw(H)+2)^{|V(G)|})$, where $bw(H)$ is the bandwidth of $\overline{H}$ (Rzążewski, 2013). This improves earlier treewidth-based parameterizations and enables subexponential algorithms when the host or pattern has small width.
• ILP and FPT Methods for Local Constraints: Locally bijective, locally injective, and locally surjective homomorphisms (LBHOM, LIHOM, LSHOM) can be tackled by integer linear programming approaches, yielding FPT algorithms for certain parameter hierarchies (Bulteau et al., 2022), with reductions to role assignment problems in social networks.

Property Testing

• Self-Testing for Linearity and Homomorphisms: For linear maps $f: \mathbb{Z}_{2^n} \to \mathbb{Z}_{2^n}$, self-testers exist with $O(1/\varepsilon)$ query complexity, independent of domain size. The tests exploit the additivity identity $f(a) + f(c) = f(a + c)$ and generalize componentwise to linear maps over $\mathbb{Z}_{2^n}^m$ (Devadas et al., 2014). This demonstrates the power of property testing in high-dimensional or infinite domains.
• Randomness-Efficient Non-Abelian Testing: For functions $f: G \to \mathbb{U}_t$ (unitary matrices), derandomized homomorphism tests in the low-soundness regime leverage small-bias sets and a degree-2 expander mixing lemma, enabling efficient estimation of Gowers $U^2$-norms and guaranteeing correlation with genuine representations even with reduced randomness (Mittal et al., 29 May 2024).

Query and Adaptive Algorithms

• Hom Algorithms and Adaptive Hom Algorithms: Membership in classes definable by Boolean combinations of universal FO sentences is decidable by a fixed set of homomorphism counts ("hom algorithm"). If nonadaptive testing is insufficient (e.g., for the class "no isolated vertex"), adaptive schemes can be leveraged, and three adaptive left-hom queries suffice to determine graph isomorphism type (Chen et al., 2021).

4. Homomorphism Indistinguishability and Logic

Homomorphism indistinguishability, the relation $$G \equiv_{\mathcal{F}} H \iff \forall F \in \mathcal{F}, \hom(F,G) = \hom(F,H)$$, provides a powerful unifying lens:

• Algorithmic Meta-Theorem: For any class $\mathcal{F}$ of bounded treewidth definable in CMSO$_2$, homomorphism indistinguishability can be decided in randomized polynomial time by reducing the infinite system of constraints to linear algebra on homomorphism tensors of size determined by the width parameter (Seppelt, 14 Feb 2024). When $k$ is fixed, this gives randomized FPT; for $k$ as input, the problem is coNP- and coW[1]-hard.
• Connections to Weisfeiler-Leman and Fractional Homomorphisms: Homomorphism indistinguishability over treewidth-$k$ graphs is equivalent to indistinguishability under the $k$-dimensional Weisfeiler-Leman algorithm, relate to fractional isomorphism and the first level of the Sherali-Adams LP hierarchy (Butti et al., 2021). These insights enable both upper and lower bounds on CSP relaxations.
• Applications to Machine Learning: Embeddings built from homomorphism counts (node or graph level) produce explainable, isomorphism-invariant feature spaces. For node embeddings, the mapping $v \mapsto ( \hom(F, G, v) )_{F \in \mathcal{K}}$ over patterns of bounded treewidth yields robust, interpretable features and connects in power to the Weisfeiler-Leman dimension and GNN expressivity (Wolf et al., 2023).

5. Special Classes: Covers, Regular Covers, and Extensions

Covers and Regular Graph Covers

• Regular Cover Algorithms: The regular cover problem, where $G$ covers $H$ via a locally bijective homomorphism prescribed by a semiregular subgroup of $\operatorname{Aut}(G)$, admits an FPT algorithm of time $O^*(2^{e(H)/2})$ for planar inputs (Fiala et al., 2016). Special cases, such as recognition of Cayley graphs and graph isomorphism, fall within this framework. For general covers, NP-hardness remains even for planar inputs and small $H$ [Bilka et al., 2011].

Homomorphism Extension

• Extension in Permutation Groups: The HomExt problem asks if a partial homomorphism from a subgroup $M \leq G$ can be extended to $G$. For $G = A_n$ and $H = S_m$ with $[G:M]$ polynomially bounded and $m < 2^{n-1}/\sqrt{n}$, the problem admits a polynomial time solution via reductions to multi-dimensional subset sum problems (MultiSSR/TriOrMultiSSR), with practical enumeration algorithms for list-decoding homomorphism codes (Wuu, 2018, Babai et al., 2018).

6. Counting, Polynomials, and Algebraic Frameworks

Homomorphism polynomials provide an algebraic view:

• For pattern $H$, the homomorphism polynomial encodes all homomorphisms from $H$ to $n$-vertex graphs, and the arithmetic (circuit, ABP, formula) complexity is characterized exactly by the treewidth, pathwidth, and treedepth of $H$, respectively. Tight lower bounds and efficient algorithms follow naturally (Komarath et al., 2020).
• The use of partition functions and edge/vertex weight matrices links to combinatorial invariants and partition functions in statistical physics; dichotomy theorems guide tractable versus intractable settings (Grohe et al., 2011).

7. Applications and Broader Implications

Algorithmic homomorphism testing underpins:

• Constraint Satisfaction: Many CSPs and their counting variants (e.g., coloring, scheduling, query answering) reduce to homomorphism existence or counting (Grohe et al., 2011, Kinne et al., 2020), with dichotomy theorems and polymorphism characterization delineating the tractable cases.
• Database Theory: Conjunctive query evaluation, containment, and equivalence testing can be expressed as homomorphism or indistinguishability problems (Cate et al., 2023).
• Machine Learning: Node and graph embeddings derived from homomorphism counts yield explainable, isomorphism-invariant features for graph-based learning (Wolf et al., 2023).
• Group Theory and Coding: Local list-decoding and code design via homomorphisms between groups, especially with extension subroutines and analysis via random generation properties (Babai et al., 2018, Wuu, 2018).
• Optimization and Relaxations: LP and SDP hierarchies (e.g., Sherali-Adams) and their feasibility correspond to logical and homomorphism indistinguishability conditions (Butti et al., 2021).

8. Open Problems and Further Directions

• Decidability and Hardness: For which (minor-closed) classes is HomInd($\mathcal{F}$) decidable? Can randomness be eliminated from current polynomial time algorithms for homomorphism indistinguishability? (Seppelt, 14 Feb 2024)
• Parameter Hierarchies: Beyond treewidth, what other parameters yield efficient algorithms for regular covers, locally constrained homomorphism, and reconstructibility (Bulteau et al., 2022, Böker et al., 2023)?
• Derandomization and Fourier Techniques: Can degree-2 expander mixing and small-bias set derandomization be systematically applied to more general non-Abelian or quantum property testing tasks (Mittal et al., 29 May 2024)?
• Bridging Logic and Algorithms: Determining the precise boundary between FO, CMSO-definability, and hom algorithm characterizations for properties and the logical preservation theorems therein (Chen et al., 2021, Cate et al., 2023).

In sum, algorithmic homomorphism testing emerges as an overview of combinatorial, algebraic, logical, and algorithmic paradigms, serving as both a fundamental computational challenge and a versatile core for interdisciplinary applications.