Reference. A cost-aware logical framework
Cite
Cited by (9)
Handling Higher-Order Effectful Operations with Judgemental Monadic Laws yang-2026-handling
Mechanizing Synthetic Tait Computability in Istari li_etal_2025
Denotational Foundations for Expected Cost Analysis amorim_2025_oopsla
Reasoning about the cost of executing programs is one of the fundamental questions in computer science. In the context of programming with probabilities, however, the notion of cost stops being deterministic, since it depends on the probabilistic samples made throughout the execution of the program. This interaction is further complicated by the non-trivial interaction between cost, recursion and evaluation strategy.
In this work we introduce cert: a Call-By-Push-Value (CBPV) metalanguage for reasoning about probabilistic cost. We equip cert with an operational cost semantics and define two denotational semantics — a cost semantics and an expected-cost semantics. We prove operational soundness and adequacy for the denotational cost semantics and a cost adequacy theorem for the expected-cost semantics.
We formally relate both denotational semantics by stating and proving a novel effect simulation property for CBPV. We also prove a canonicity property of the expected-cost semantics as the minimal semantics for expected cost and probability by building on recent advances on monadic probabilistic semantics.
Finally, we illustrate the expressivity of cert and the expected-cost semantics by presenting case-studies ranging from randomized algorithms to stochastic processes and show how our semantics capture their intended expected cost.
The Compositional Essence of Effectful Cost Analyses: Categorical Foundations and Fibered Logical Relations amorim_effcost
Cost-sensitive computational adequacy of higher-order recursion in synthetic domain theory niu-2024-cost
Polynomial Time and Dependent Types atkey-2024-polynomial
Decalf: A Directed, Effectful Cost-Aware Logical Framework grodin-2024-decalf
Strict universes for Grothendieck topoi gratzer-2022-strict
First Steps in Synthetic Tait Computability: The Objective Metatheory of Cubical Type Theory sterling_2021
Cites 74 works (7 here)
With notes (7)
Quotients, inductive types, and quotient inductive types fiore-2022-quotients
Logical Relations as Types: Proof-Relevant Parametricity for Program Modules sterling_harper_2021
The theory of program modules is of interest to language designers not only for its practical importance to programming, but also because it lies at the nexus of three fundamental concerns in language design: the phase distinction, computational effects, and type abstraction. We contribute a fresh “synthetic” take on program modules that treats modules as the fundamental constructs, in which the usual suspects of prior module calculi (kinds, constructors, dynamic programs) are rendered as derived notions in terms of a modal type-theoretic account of the phase distinction. We simplify the account of type abstraction (embodied in the generativity of module functors) through a lax modality that encapsulates computational effects, placing projectibility of module expressions on a type-theoretic basis.
Our main result is a (significant) proof-relevant and phase-sensitive generalization of the Reynolds abstraction theorem for a calculus of program modules, based on a new kind of logical relation called a parametricity structure. Parametricity structures generalize the proof-irrelevant relations of classical parametricity to proof-relevant families, where there may be non-trivial evidence witnessing the relatedness of two programs—simplifying the metatheory of strong sums over the collection of types, for although there can be no “relation classifying relations,” one easily accommodates a “family classifying small families.”
Using the insight that logical relations/parametricity is itself a form of phase distinction between the syntactic and the semantic, we contribute a new synthetic approach to phase separated parametricity based on the slogan logical relations as types, by iterating our modal account of the phase distinction. We axiomatize a dependent type theory of parametricity structures using two pairs of complementary modalities (syntactic, semantic) and (static, dynamic), substantiated using the topos theoretic Artin gluing construction. Then, to construct a simulation between two implementations of an abstract type, one simply programs a third implementation whose type component carries the representation invariant.
Normalization for Cubical Type Theory sterling_angiuli_2021
Modalities in homotopy type theory rijke-2020-modalities
Iris from the ground up: A modular foundation for higher-order concurrent separation logic jung_etal_iris_ground_up_2018
Iris: Monoids and Invariants as an Orthogonal Basis for Concurrent Reasoning jung-2015-iris
Call-By-Push-Value: A Functional/Imperative Synthesis levy-2003-callbypushvalue
External (67)
- agda-calf (2022)
- Peter Lammich, Christian Sternagel, Simon Wimmer, and Bohua Zhan (2021)
- A unifying type-theory for higher-order (amortized) cost analysis (2021)
- Formalising perfectoid spaces (2020)
- Rast: A Language for Resource-Aware Session Types (2020)
- A formal proof of the independence of the continuum hypothesis (2020)
- Syntactic categories for dependent type theory: sketching and adequacy (2020)
- Cost-Aware Type Theory (2020)
- Liquidate your assets: reasoning about resource usage in liquid Haskell (2019)
- Recurrence extraction for functional programs through call-by-push-value (2019)
- Time Credits and Time Receipts in Iris (2019)
- The fire triangle: how to mix substitution, dependent elimination, and effects (2019)
- Temporal Type Theory: A Topos-Theoretic Approach to Systems and Behavior (2019)
- Algorithms: Parallel and Sequential (2019)
- A General Framework for the Semantics of Type Theory (2019)
- Canonicity and normalisation for Dependent Type Theory (2018)
- Parallel complexity analysis with temporal session types (2018)
- PFPL Supplement: Types and Parallelism (2018)
- Work Analysis with Resource-Aware Session Types (2017)
- Dual-context calculi for modal logic (2017)
- TiML: a functional language for practical complexity analysis with invariants (2017)
- The Median-of-Medians Selection Algorithm (2017)
- The number of comparisons in QuickSort (2017)
- Normalisation by Evaluation for Dependent Types (2016)
- Type theory in type theory using quotient inductive types (2016)
- Guarded Dependent Type Theory with Coinductive Types (2016)
- Verified Functional Programming in Agda (2016)
- The Coq Proof Assistant Reference Manual (2016)
- Simple Verification of Rust Programs via Functional Purification (2016)
- Denotational cost semantics for functional languages with inductive types (2015)
- A Model of PCF in Guarded Type Theory (2015)
- The Akra-Bazzi theorem and the Master theorem (2015)
- Idris, a general-purpose dependently typed programming language: Design and implementation (2013)
- Certified Programming with Dependent Types: A Pragmatic Introduction to the Coq Proof Assistant (2013)
- Resource Aware ML (2012)
- First Steps in Synthetic Guarded Domain Theory: Step-Indexing in the Topos of Trees (2011)
- Amortised Resource Analysis with Separation Logic (2010)
- Static determination of quantitative resource usage for higher-order programs (2010)
- Introduction to Algorithms, 3rd Edition (2009)
- Dependently Typed Programming in Agda (2009)
- Lightweight semiformal time complexity analysis for purely functional data structures (2008)
- Formal Proof—The Four- Color Theorem (2008)
- Space profiling for parallel functional programs (2008)
- Towards a mechanized metatheory of standard ML (2007)
- Call-by-push-value: Decomposing call-by-value and call-by-name (2006)
- Modelling general recursion in type theory (2005)
- General recursion via coinductive types (2005)
- Static prediction of heap space usage for first-order functional programs (2003)
- Computational complexity and induction for partial computable functions in type theory (2002)
- A modal analysis of staged computation (2001)
- Intensionality, extensionality, and proof irrelevance in modal type theory (2001)
- Resource bound certification (2000)
- A Type System for Bounded Space and Functional In-Place Update (2000)
- A provably time-efficient parallel implementation of full speculation (1999)
- Purely Functional Data Structures (1998)
- A provable time and space efficient implementation of NESL (1996)
- Parallelism in sequential functional languages (1995)
- Higher-order modules and the phase distinction (1990)
- Implementing Mathematics with the Nuprl Proof Development System (1986)
- Amortized Computational Complexity (1985)
- The Type Theory of PL/CV3 (1984)
- An Efficient Functional Implementation of FIFO Queues (1982)
- Real-Time Queue Operation in Pure LISP (1980)
- LCF Considered as a Programming Language (1977)
- Recursive predicates and quantifiers (1943)
- Topo-logie
- The Science of Programming