An Implicit Characterization of PSPACE

We present a type system for an extension of lambda calculus with a conditional construction, named STAB, that characterizes the PSPACE class. This system is obtained by extending STA, a type assignment for lambda-calculus inspired by Lafont’s Soft Linear Logic and characterizing the PTIME class. We extend STA by means of a ground type and terms for booleans and conditional. The key issue in the design of the type system is to manage the contexts in the rule for conditional in an additive way. Thanks to this rule, we are able to program polynomial time Alternating Turing Machines. From the well-known result APTIME = PSPACE, it follows that STAB is complete for PSPACE. Conversely, inspired by the simulation of Alternating Turing machines by means of Deterministic Turing machine, we introduce a call-by-name evaluation machine with two memory devices in order to evaluate programs in polynomial space. As far as we know, this is the first characterization of PSPACE that is based on lambda calculus and light logics.

💡 Research Summary

The paper introduces STAB, a type system for an extension of the lambda calculus that precisely captures the complexity class PSPACE. STAB builds on STA, a type assignment inspired by Lafont’s Soft Linear Logic that characterizes PTIME, by adding a ground Boolean type and a conditional construct. The central technical contribution is an additive treatment of contexts in the conditional typing rule: the same typing context is shared by both branches of an “if‑then‑else” expression, avoiding the exponential blow‑up that would result from duplicating resources. This additive rule enables a direct encoding of alternating Turing machines (ATMs) within the lambda calculus: the “then” branch corresponds to an existential choice, while the “else” branch corresponds to a universal choice. Consequently, any computation performed by a polynomial‑time ATM can be expressed as a well‑typed STAB term.

Since APTIME (the class of problems solvable by ATMs in polynomial time) is known to be equal to PSPACE, the authors prove that STAB is both sound and complete for PSPACE. In other words, every PSPACE problem can be represented by a STAB‑typed term, and every STAB‑typed term can be evaluated using at most polynomial space.

To substantiate the space bound, the paper presents a call‑by‑name evaluation machine equipped with two memory devices: a stack that records the current evaluation environment and a heap that stores reusable shared structures (such as closures). When a conditional is evaluated, the machine forks the computation, preserving the two possible continuations in separate memory regions while reusing the same context. The design guarantees that the total memory consumption never exceeds a polynomial function of the input size, thereby mirroring the classic simulation of ATMs by deterministic Turing machines.

The authors provide a full formalization of the typing rules, the operational semantics of the evaluation machine, and rigorous proofs of both completeness (every PSPACE language has a corresponding STAB term) and soundness (evaluation of any STAB term stays within polynomial space). They also discuss how STAB differs from previous light‑logic characterizations, which have been limited to PTIME, and argue that STAB is the first lambda‑calculus‑based, light‑logic‑inspired system that reaches PSPACE.

Finally, the paper outlines future work, including the development of compilers that target STAB, extensions toward higher complexity classes (e.g., EXPTIME), and experimental validation of the evaluation machine on real hardware. By bridging type theory, lambda calculus, and space‑bounded computation, the work opens a new avenue for understanding and exploiting complexity classes through programming language design.