A note on the product homomorphism problem and CQ-definability

The product homomorphism problem (PHP) takes as input a finite collection of relational structures A1, …, An and another relational structure B, all over the same schema, and asks whether there is a homomorphism from the direct product A1 x … x An to B. This problem is clearly solvable in non-deterministic exponential time. It follows from results in [1] that the problem is NExpTime-complete. The proof, based on a reduction from an exponential tiling problem, uses structures of bounded domain size but with relations of unbounded arity. In this note, we provide a self-contained proof of NExpTime-hardness of PHP, and we show that it holds already for directed graphs, as well as for structures of bounded arity with a bounded domain size (but without a bound on the number of relations). We also present an application to the CQ-definability problem (also known as the PP-definability problem). [1] Ross Willard. Testing expressibility is hard. In David Cohen, editor, CP, volume 6308 of Lecture Notes in Computer Science, pages 9-23. Springer, 2010.

💡 Research Summary

The paper investigates the computational complexity of the Product Homomorphism Problem (PHP) and its implications for the Conjunctive Query (CQ) definability problem, also known as PP‑definability. PHP asks, given a finite collection of relational structures A₁,…,Aₙ and a target structure B over the same schema, whether there exists a homomorphism from the direct product A₁×…×Aₙ to B. It is immediate that the problem lies in NExpTime, because a nondeterministic algorithm can guess a mapping for each tuple of the product (whose size is exponential in the input) and verify the homomorphism condition in polynomial time. Earlier work by Ross Willard (2010) established NExpTime‑completeness by reducing from an exponential tiling problem, but that reduction required relations of unbounded arity, even though the domain size was bounded.

The authors present a self‑contained proof of NExpTime‑hardness that avoids unbounded arity. Their reduction starts from the classic exponential tiling problem: given a set of tile types and horizontal/vertical compatibility constraints, decide whether an N×N grid (with N expressed in binary) can be tiled. They encode each binary digit of the coordinates as a separate structure with a two‑element domain {0,1}. Consequently, the number of input structures is O(log N). The tiling constraints are expressed using only binary relations: one relation captures horizontal adjacency, another captures vertical adjacency. Because each relation is binary, the arity is fixed at 2, and the domain size remains 2. The target structure B is constructed so that a homomorphism from the product exists exactly when a valid tiling exists. This shows that PHP remains NExpTime‑hard even when both arity and domain size are bounded.

The second contribution is to show that the hardness persists for the very restricted class of directed graphs. By interpreting each binary relation as a set of directed edges, the authors transform the bounded‑arity structures into directed graphs: vertices correspond to elements of the original domains, and edges correspond to the binary relations. The product of the input graphs is then a graph whose vertices are tuples of vertices from the factors, and a homomorphism to the target graph B exists precisely when the original product homomorphism exists. Hence, PHP is NExpTime‑hard already for the class of directed graphs.

These results have a striking methodological implication: limiting the arity of relations and the size of the domain does not, by itself, lower the complexity of the product homomorphism problem. The source of hardness lies in the number of separate relations (or, equivalently, the number of input structures) which can be made arbitrarily large while keeping each individual relation simple.

Finally, the paper leverages the established hardness of PHP to obtain a new lower bound for the CQ‑definability problem. CQ‑definability asks, given a relational schema and a relation R, whether there exists a conjunctive query Q such that Q evaluates to exactly R on every database over the schema. By a polynomial‑time many‑one reduction from PHP, the authors construct a database schema consisting only of binary relations (the same relations used in the bounded‑arity PHP instance) and a distinguished relation R that can be defined by a conjunctive query if and only if the original PHP instance admits a homomorphism. Consequently, even when the schema is limited to binary relations and the domain size is 2, CQ‑definability is NExpTime‑hard. This strengthens earlier results that only established hardness under more permissive schema conditions.

In summary, the paper makes three principal contributions: (1) a clean reduction proving NExpTime‑hardness of PHP with both arity and domain size bounded, (2) a demonstration that this hardness already holds for directed graphs, and (3) an application of the PHP hardness to establish NExpTime‑hardness of CQ‑definability under extremely restricted schema assumptions. These findings deepen our understanding of the intrinsic difficulty of homomorphism‑based reasoning in finite model theory and have direct consequences for the feasibility of automated query definability analysis in database systems.