Safe Recursion on Notation into a Light Logic by Levels

We embed Safe Recursion on Notation (SRN) into Light Affine Logic by Levels (LALL), derived from the logic L4. LALL is an intuitionistic deductive system, with a polynomial time cut elimination strategy. The embedding allows to represent every term t of SRN as a family of proof nets |t|^l in LALL. Every proof net |t|^l in the family simulates t on arguments whose bit length is bounded by the integer l. The embedding is based on two crucial features. One is the recursive type in LALL that encodes Scott binary numerals, i.e. Scott words, as proof nets. Scott words represent the arguments of t in place of the more standard Church binary numerals. Also, the embedding exploits the “fuzzy” borders of paragraph boxes that LALL inherits from L4 to “freely” duplicate the arguments, especially the safe ones, of t. Finally, the type of |t|^l depends on the number of composition and recursion schemes used to define t, namely the structural complexity of t. Moreover, the size of |t|^l is a polynomial in l, whose degree depends on the structural complexity of t. So, this work makes closer both the predicative recursive theoretic principles SRN relies on, and the proof theoretic one, called /stratification/, at the base of Light Linear Logic.

💡 Research Summary

The paper establishes a precise embedding of Safe Recursion on Notation (SRN) into Light Affine Logic by Levels (LALL), a proof‑theoretic system derived from the logic L4. SRN characterises polynomial‑time computable functions by separating arguments into “safe” and “normal” (or “dangerous”) parts and by restricting recursion to operate only on the safe arguments. LALL, on the other hand, is an intuitionistic variant of Light Linear Logic (LLL) that introduces two crucial mechanisms: a level‑based stratification of formulas and a “fuzzy” paragraph‑box discipline inherited from L4. The fuzzy boxes allow overlapping of box boundaries, which in turn permits controlled duplication of sub‑proofs that would otherwise be forbidden in strict Light Linear Logic.

The authors first formalise LALL, presenting its syntax, typing rules, and a polynomial‑time cut‑elimination procedure. They then define a recursive type μγ·(γ⊸γ)⊸γ that encodes Scott binary numerals (Scott words). Unlike Church numerals, Scott words expose their bits directly, making them amenable to linear‑time manipulation and, crucially, to the free duplication of safe arguments inside fuzzy boxes.

The core of the embedding maps each SRN term t to a family of proof‑nets |t|^ℓ, indexed by a natural number ℓ that bounds the bit‑length of the inputs. For any input whose binary representation has length ≤ ℓ, the proof‑net |t|^ℓ computes exactly the same result as t. The construction proceeds inductively on the structure of t: basic functions (zero, successor, predecessor, projection) are represented by small, constant‑size nets; composition and safe recursion are handled by nesting fuzzy boxes and by raising the level of the net according to the number of recursion/composition schemes used. This number, called the structural complexity s(t), determines both the depth of box nesting and the maximal level appearing in the type of |t|^ℓ.

A detailed quantitative analysis shows that the size of |t|^ℓ is bounded by a polynomial O(ℓ^d), where the exponent d depends only on s(t). Consequently, the family of nets grows only polynomially with the input size, and the cut‑elimination process on any |t|^ℓ terminates in polynomial time. The fuzzy boxes are essential here: they allow the safe arguments to be duplicated arbitrarily inside the box without violating the level constraints, while dangerous arguments remain confined to a single level, preventing uncontrolled blow‑up.

The paper also proves soundness and completeness of the embedding: every SRN function can be represented by some family {|t|^ℓ} and, conversely, any LALL proof‑net of the appropriate type corresponds to an SRN function of comparable structural complexity. This establishes a tight correspondence between the predicative recursion principles underlying SRN and the stratification discipline that guarantees polynomial‑time cut elimination in Light Linear Logic.

In conclusion, the work bridges two historically separate approaches to implicit computational complexity—recursive function theory (SRN) and proof‑theoretic light logics (LALL). By exploiting recursive Scott encodings and the flexibility of fuzzy paragraph boxes, the authors achieve a faithful, size‑controlled embedding that preserves polynomial‑time behaviour on both sides. The results open avenues for further exploration of light logics with richer type systems, for transferring complexity‑preserving transformations between programming languages and logical systems, and for deepening our understanding of the structural reasons why certain syntactic restrictions enforce feasible computation.