[Paper Review] Implicit complexity via structure transformation

Daniël Leivant, Jean-Yves Marion|arXiv (Cornell University)|Feb 9, 2018

semigroups and automata theory13 references3 citations

TL;DR

This paper introduces STV, a Turing-complete imperative language for transforming finite structures that directly captures primitive recursive (PR) functions over free algebras via loop variants. By treating inductive data objects like natural numbers and strings as finite structures, the authors establish a direct, variant-based program construction that characterizes PR complexity without relying on data-driven recurrence, unifying descriptive and programming approaches in implicit computational complexity.

ABSTRACT

Implicit computational complexity, which aims at characterizing complexity classes by machine-independent means, has traditionally been based, on the one hand, on programs and deductive formalisms for free algebras, and on the other hand on descriptive tools for finite structures. We consider here "uninterpreted" programs for the transformation of finite structures, which define functions over a free algebra A once the elements of A are themselves considered as finite structures. We thus bridge the gap between the two approaches above to implicit complexity, with the potential of streamlining and clarifying important tools and techniques, such as set-existence and ramification. We illustrate this potential by delineating a broad class of programs, based on the notion of loop variant familiar from imperative program construction, that characterizes a generic notion of primitive-recursive complexity, without reference to any data-driven recurrence.

Motivation & Objective

• To unify descriptive complexity (finite structures) and programming-based implicit complexity (infinite structures) by treating inductive data as finite structures.
• To develop a direct, machine-independent characterization of primitive recursion without relying on data-driven recurrence.
• To demonstrate that a variant-based imperative language (STV) captures exactly the class of primitive recursive functions over any free algebra.
• To clarify foundational concepts like set-existence and ramification through a unified framework of structure transformation.
• To provide a direct, constructive mapping from PR definitions to programs, avoiding indirect coding via natural numbers.

Proposed method

• The paper introduces STV, an imperative language for transforming finite partial-structures using loop variants, inspired by Gurevich’s Abstract State Machines.
• It represents inductive data (e.g., natural numbers, strings) as finite structures with tokens and pointers, enabling uniform treatment of data and computation.
• The core technique uses monotone enumerators and quasi-inverses to navigate and decompose structures, allowing recursive traversal without explicit recursion.
• A loop variant is used to ensure termination and bound resource usage, with the variant being a structure (e.g., a list of nodes) that strictly decreases with each iteration.
• The method constructs STV programs that simulate recurrence by recursively building results via substructure decomposition and function invocation.
• It proves completeness by showing that any PR function over a free algebra can be directly encoded as an STV program, and that any ST program running in PR time can be emulated by an STV program using a time-bound variant.

Experimental results

Research questions

• RQ1 Can primitive recursion over free algebras be directly characterized using a variant-based imperative language operating on finite structures?
• RQ2 How can the gap between descriptive complexity (finite structures) and programming-based implicit complexity (infinite structures) be bridged?
• RQ3 Can loop variants in imperative programs be used to uniformly capture primitive recursive resource bounds without relying on data-driven recurrence?
• RQ4 Is there a direct, constructive mapping from PR definitions to programs that avoids indirect encodings via natural numbers?
• RQ5 Can STV programs simulate any ST program running in primitive-recursive time, using structure-based variants?

Key findings

• STV programs directly capture all primitive recursive functions over any free algebra, establishing a complete and direct correspondence with the class PR(𝒜).
• The language STV is shown to be complete for PR(𝒜) via a constructive proof that maps each recurrence instance to a corresponding STV program.
• The paper proves that any ST program running in primitive-recursive time can be emulated by an STV program by using a time-bound variant constructed from a node enumerator.
• The size of a structure is polynomially bounded in the number of nodes, ensuring that resource bounds in STV are primitive-recursive in input size.
• The approach provides a natural framework for reasoning about ramification and set-existence by operating directly on finite structures.
• The method avoids indirect encodings by treating inductive data as finite structures, thereby streamlining the characterization of complexity classes.