Dependently-Typed AARA: A Non-Affine Approach for Resource Analysis of Higher-Order Programs

2026-01-19

AI Summary

Existing static resource analyses based on affine type systems struggle to precisely characterize the resource consumption of higher-order functions, particularly under partial application. This work proposes λ_amor^na, the first type system integrating dependent types into a non-affine AARA (Automatic Amortized Resource Analysis) framework. By decoupling resource annotations from standard types and adopting a non-affine mechanism, λ_amor^na effectively resolves the tension between affine constraints and higher-order typing. The system enables independent definition of potential functions at the type level, facilitating precise and compositional reasoning about resource usage in higher-order functional programs. Formal semantics and a soundness proof guarantee the correctness of derived resource bounds, while experimental evaluation demonstrates its superior expressiveness and analytical precision.

Technology Category

• Knowledge Representation and Reasoning: Nonmonotonic Reasoning
• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories
• Multiagent Systems: Agreement, Argumentation & Negotiation

Application Category

• Systems and Infrastructure for Web, Mobile and WoT: Virtualization and resource management in Web systems and infrastructures
• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Responsible Web: Human-perceived consequences of algorithmic deployment on the web

Abstract

Static resource analysis determines the resource consumption (e.g., time complexity) of a program without executing it. Among the numerous existing approaches for resource analysis, affine type systems have been one dominant approach. However, these affine type systems fall short of deriving precise resource behavior of higher-order programs, particularly in cases that involve partial applications. This article presents \lambda_\ms{amor}^\ms{na}}, a non-affine AARA-style dependent type system for resource reasoning about higher-order functional programs. The key observation is that the main issue in previous approaches comes from (i) the close coupling of types and resources, and (ii) the conflict between affine and higher-order typing mechanisms. To derive precise resource behavior of higher-order functions, \lambda_\ms{amor}^\ms{na}} decouples resources from types and follows a non-affine typing mechanism. The non-affine type system of \lambda_\ms{amor}^\ms{na}} achieves this by using dependent types, which allows expressing type-level potential functions separate from ordinary types. This article formalizes \lambda_\ms{amor}^\ms{na}}'s syntax and semantics, and proves its soundness, which guarantees the correctness of resource bounds. Several challenging classic and higher-order examples are presented to demonstrate the expressiveness and compositionality of \lambda_\ms{amor}^\ms{na}}'s reasoning capability.

Problem

• resource analysis
• higher-order programs
• affine type systems
• dependent types
• static analysis

Innovation

• dependent types
• non-affine typing
• resource analysis
• higher-order programs
• AARA