Church => Scott = Ptime: an application of resource sensitive realizability

We introduce a variant of linear logic with second order quantifiers and type fixpoints, both restricted to purely linear formulas. The Church encodings of binary words are typed by a standard non-linear type Church,' while the Scott encodings (purely linear representations of words) are by a linear type Scott.’ We give a characterization of polynomial time functions, which is derived from (Leivant and Marion 93): a function is computable in polynomial time if and only if it can be represented by a term of type Church => Scott. To prove soundness, we employ a resource sensitive realizability technique developed by Hofmann and Dal Lago.

💡 Research Summary

The paper presents a novel variant of linear logic that incorporates second‑order quantification and type fixpoints, but restricts both constructs to purely linear formulas. This restriction preserves the resource‑sensitive nature of linear logic while granting enough expressive power to encode recursive definitions and higher‑order functions. Within this logical framework the authors distinguish two canonical representations of binary words: the classical Church encoding, which lives in a non‑linear type called Church, and the purely linear Scott encoding, which inhabits a linear type called Scott.

The central theorem states that a function f is computable in polynomial time if and only if there exists a λ‑term t of type Church ⇒ Scott that implements f. In other words, the arrow from the non‑linear Church world to the linear Scott world characterizes exactly the class P. The “if” direction (completeness) builds on the earlier work of Leivant and Marion (1993), who showed that a second‑order linear system with restricted quantification captures all polynomial‑time functions. By translating their construction into the present setting—using Church‑encoded inputs and Scott‑encoded outputs—the authors demonstrate that every poly‑time function can be expressed as a term of type Church ⇒ Scott.

The “only‑if” direction (soundness) is proved using a resource‑sensitive realizability model originally developed by Hofmann and Dal Lago. This model associates each term with a quantitative resource bound and verifies that the bound grows at most polynomially with the size of the input. The authors adapt the realizability semantics to accommodate the added second‑order quantifiers and fixpoint operators, showing that these extensions do not break the polynomial bound because they are confined to linear formulas. In particular, the μ/ν fixpoints encode recursion in a way that each recursive call consumes a fresh linear resource, preventing uncontrolled duplication. The second‑order quantifiers are interpreted so that they cannot introduce hidden copying either. Consequently, any term of type Church ⇒ Scott is guaranteed to evaluate within a time that is a polynomial function of the length of its Church‑encoded argument.

Beyond the main theorem, the paper provides a detailed syntactic description of the logic, including typing rules for linear implication, tensor, linear quantifiers, and the two fixpoint operators. It also defines the encoding of binary words: a Church word is a higher‑order function that iterates a given step function, while a Scott word is a linear stream where each bit is consumed exactly once. The translation from Church to Scott is realized by a term that traverses the Church iterator, extracts each bit, and builds the corresponding linear stream, all while respecting the linear usage discipline.

The authors discuss several implications of their result. First, it offers a clean logical characterization of P that is entirely type‑theoretic: by checking that a program’s type is Church ⇒ Scott, one can guarantee polynomial‑time execution without any external complexity analysis. Second, the approach illustrates how linear logic’s intrinsic resource tracking can be leveraged for implicit computational complexity, bridging the gap between proof theory and algorithmic complexity. Third, the methodology suggests a pathway to extend the characterization to other complexity classes (e.g., NP or LOGSPACE) by altering the linearity constraints or the allowed fixpoint operators.

In summary, the paper introduces a linear‑logic‑based type system that precisely captures polynomial‑time computable functions via the type Church ⇒ Scott. The completeness proof relies on prior implicit complexity results, while the soundness proof employs a refined resource‑sensitive realizability model. This work deepens the connection between linear logic, type theory, and computational complexity, and opens avenues for further research on type‑driven complexity guarantees.