https://calfproject.github.io/hgrodin/ hgrodin /hgrodin/ Harrison Grodin Person https://www.harrisongrodin.com Carnegie Mellon University 0000-0002-0947-3520 Ph.D. Student Harrison Grodin is a fourth-year Ph.D. student in the Principles of Programming group in the Computer Science Department at Carnegie Mellon University, advised by Robert Harper. His research is on programming language semantics, drawing inspiration from ideas in type theory and category theory. References Context https://calfproject.github.io/team-phd-current/ team-phd-current /team-phd-current/ Current Ph.D. Students Team https://calfproject.github.io/hgrodin/ hgrodin /hgrodin/ Harrison Grodin Person https://www.harrisongrodin.com Carnegie Mellon University 0000-0002-0947-3520 Ph.D. Student Harrison Grodin is a fourth-year Ph.D. student in the Principles of Programming group in the Computer Science Department at Carnegie Mellon University, advised by Robert Harper. His research is on programming language semantics, drawing inspiration from ideas in type theory and category theory. https://calfproject.github.io/runmingl/ runmingl /runmingl/ Runming Li Person https://www.cs.cmu.edu/~runmingl/ Carnegie Mellon University 0000-0001-7600-9069 Ph.D. Student Runming Li is a second-year Ph.D. student in the Computer Science Department at Carnegie Mellon University, advised by Prof. Robert Harper. He studies semantics of programming languages from the perspectives of (dependent) type theory and category theory. More broadly, he is interested in the design and implementation of functional programming languages and proof assistants that facilitate the construction and verification of correct and efficient programs. https://calfproject.github.io/ethanchu/ ethanchu /ethanchu/ Ethan Chu Person https://gediminas19.github.io Carnegie Mellon University 0009-0005-6041-0313 Ph.D. Student Ethan Chu is a 2nd-year PhD student in the Principles of Programming (PoP) group in Carnegie Mellon University’s Computer Science Department (CMU CSD), advised by Jan Hoffmann. His research areas are programming languages and verification, with a focus on type systems and static resource analysis of programs. Backlinks Related https://calfproject.github.io/cmu/ cmu /cmu/ Carnegie Mellon University Institution https://www.cmu.edu/ Pittsburgh, PA, USA https://calfproject.github.io/rwh/ rwh /rwh/ Robert Harper Person https://www.cs.cmu.edu/~rwh/ Carnegie Mellon University 0000-0002-9400-2941 Professor Contributions Yue Niu Jon Sterling Harrison Grodin Robert Harper https://calfproject.github.io/niu-sterling-grodin-harper-2022/ niu-sterling-grodin-harper-2022 /niu-sterling-grodin-harper-2022/ A Cost-Aware Logical Framework Reference POPL ’22: 49th ACM SIGPLAN Symposium on Principles of Programming Languages 10.1145/3498670 2022, title = {A Cost-Aware Logical Framework}, author = {Niu, Yue and Sterling, Jonathan and Grodin, Harrison and Harper, Robert}, year = {2022}, month = jan, journal = {Proc. ACM Program. Lang.}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, volume = {6}, number = {POPL}, doi = {10.1145/3498670}, url = {https://doi.org/10.1145/3498670}, issue_date = {January 2022}, articleno = {9}, numpages = {31}, keywords = {algorithm analysis, amortized analysis, behavioral verification, cost models, equational reasoning, intensional property, mechanized proof, modal type theory, noninterference, parallel algorithms, phase distinction, proof assistants, recurrence relations} }]]> We present Calf, a cost-aware logical framework for studying quantitative aspects of functional programs. Taking inspiration from recent work that reconstructs traditional aspects of programming languages in terms of a modal account of phase distinctions, we argue that the cost structure of programs motivates a phase distinction between intension and extension. Armed with this technology, we contribute a synthetic account of cost structure as a computational effect in which cost-aware programs enjoy an internal noninterference property: input/output behavior cannot depend on cost. As a full-spectrum dependent type theory, Calf presents a unified language for programming and specification of both cost and behavior that can be integrated smoothly with existing mathematical libraries available in type theoretic proof assistants. We evaluate Calf as a general framework for cost analysis by implementing two fundamental techniques for algorithm analysis: the method of recurrence relations and physicist’s method for amortized analysis. We deploy these techniques on a variety of case studies: we prove a tight, closed bound for Euclid’s algorithm, verify the amortized complexity of batched queues, and derive tight, closed bounds for the sequential and parallel complexity of merge sort, all fully mechanized in the Agda proof assistant. Lastly we substantiate the soundness of quantitative reasoning in Calf by means of a model construction. Runming Li Harrison Grodin Robert Harper https://calfproject.github.io/li-grodin-harper-2023/ li-grodin-harper-2023 /li-grodin-harper-2023/ A Verified Cost Analysis of Joinable Red-Black Trees Reference Manuscript 10.48550/arXiv.2309.11056 2023, title = {A Verified Cost Analysis of Joinable Red-Black Trees}, author = {Runming Li and Harrison Grodin and Robert Harper}, year = {2023}, url = {https://arxiv.org/abs/2309.11056}, eprint = {2309.11056}, archiveprefix = {arXiv}, primaryclass = {cs.PL} }]]> Ordered sequences of data, specified with a join operation to combine sequences, serve as a foundation for the implementation of parallel functional algorithms. This abstract data type can be elegantly and efficiently implemented using balanced binary trees, where a join operation is provided to combine two trees and rebalance as necessary. In this work, we present a verified implementation and cost analysis of joinable red-black trees in Calf, a dependent type theory for cost analysis. We implement red-black trees and auxiliary intermediate data structures in such a way that all correctness invariants are intrinsically maintained. Then, we describe and verify precise cost bounds on the operations, making use of the red-black tree invariants. Finally, we implement standard algorithms on sequences using the simple join-based signature and bound their cost in the case that red-black trees are used as the underlying implementation. All proofs are formally mechanized using the embedding of Calf in the Agda theorem prover. Harrison Grodin Runming Li Robert Harper https://calfproject.github.io/grodin-li-harper-2026/ grodin-li-harper-2026 /grodin-li-harper-2026/ Abstraction Functions as Types: Modular Verification of Cost and Behavior in Dependent Type Theory Reference POPL ’26: 53rd ACM SIGPLAN Symposium on Principles of Programming Languages 10.1145/3776673 2026, title = {Abstraction Functions as Types: Modular Verification of Cost and Behavior in Dependent Type Theory}, author = {Grodin, Harrison and Li, Runming and Harper, Robert}, year = 2026, month = jan, journal = {Proc. ACM Program. Lang.}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, volume = 10, number = {POPL}, doi = {10.1145/3776673}, url = {https://doi.org/10.1145/3776673}, issue_date = {January 2026}, articleno = 31, numpages = 28, keywords = {abstract data type, abstraction, abstraction function, algorithm, algorithm analysis, call-by-push-value, concrete type, cost analysis, data structure, dependent type theory, equational reasoning, information flow, modal type theory, modularity, noninterference, phase distinction, verification} }]]> Software development depends on the use of libraries whose public specifications inform client code and impose obligations on private implementations; it follows that verification at scale must also be modular, preserving such abstraction. Hoare’s influential methodology uses abstraction functions to demonstrate the coherence between such concrete implementations and their abstract specifications. However, the Hoare methodology relies on a conventional separation between implementation and specification, providing no linguistic support for ensuring that this convention is obeyed. This paper proposes a synthetic account of Hoare’s methodology within univalent dependent type theory by encoding the data of abstraction functions within types themselves. This is achieved via a phase distinction, which gives rise to a gluing construction that renders an abstraction function as a type and a pair of modalities that fracture a type into its concrete and abstract parts. A noninterference theorem governing the phase distinction characterizes the modularity guarantees provided by the theory. This approach scales to verification of cost, allowing the analysis of client cost relative to a cost-aware specification. A monadic sealing effect facilitates modularity of cost, permitting an implementation to be upper-bounded by its specification in cases where private details influence observable cost. The resulting theory supports modular development of programs and proofs in a manner that hides private details of no concern to clients while permitting precise specifications of both the cost and behavior of programs. Harrison Grodin Robert Harper https://calfproject.github.io/grodin-harper-2024/ grodin-harper-2024 /grodin-harper-2024/ Amortized Analysis via Coalgebra Reference MFPS '24: 40th Conference on Mathematical Foundations of Programming Semantics 10.46298/entics.14797 2024, title = {Amortized Analysis via Coalgebra}, author = {Harrison Grodin and Robert Harper}, year = {2024}, month = {Dec}, journal = {Electronic Notes in Theoretical Informatics and Computer Science}, volume = {Volume 4 - Proceedings of MFPS XL}, doi = {10.46298/entics.14797}, issn = {2969-2431}, url = {https://entics.episciences.org/14797}, eid = {10}, keywords = {Computer Science - Programming Languages, Computer Science - Data Structures and Algorithms, Mathematics - Category Theory} }]]> Amortized analysis is a cost analysis technique for data structures in which cost is studied in aggregate: rather than considering the maximum cost of a single operation, one bounds the total cost encountered throughout a session. Traditionally, amortized analysis has been phrased inductively, quantifying over finite sequences of operations. Connecting to prior work on coalgebraic semantics for data structures, we develop the alternative perspective that amortized analysis is naturally viewed coalgebraically in a category of cost algebras, where a morphism of coalgebras serves as a first-class generalization of potential function suitable for integrating cost and behavior. Using this simple definition, we consider amortization of other sample effects, non-commutative printing and randomization. To support imprecise amortized upper bounds, we adapt our discussion to the bicategorical setting, where a potential function is a colax morphism of coalgebras. We support algebraic and coalgebraic operations simultaneously by using coalgebras for an endoprofunctor instead of an endofunctor, combining potential using a monoidal structure on the underlying category. Finally, we compose amortization arguments in the indexed category of coalgebras to implement one amortized data structure in terms of others. Harrison Grodin Robert Harper https://calfproject.github.io/grodin-harper-2023/ grodin-harper-2023 /grodin-harper-2023/ Amortized Analysis via Coinduction Reference CALCO '23: 10th Conference on Algebra and Coalgebra in Computer Science (CALCO 2023) 10.4230/LIPIcs.CALCO.2023.23 2023, title = {{Amortized Analysis via Coinduction}}, author = {Grodin, Harrison and Harper, Robert}, year = {2023}, booktitle = {10th Conference on Algebra and Coalgebra in Computer Science (CALCO 2023)}, publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik}, address = {Dagstuhl, Germany}, series = {Leibniz International Proceedings in Informatics (LIPIcs)}, volume = {270}, pages = {23:1--23:6}, doi = {10.4230/LIPIcs.CALCO.2023.23}, isbn = {978-3-95977-287-7}, issn = {1868-8969}, url = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.CALCO.2023.23}, editor = {Baldan, Paolo and de Paiva, Valeria}, urn = {urn:nbn:de:0030-drops-188201}, annote = {Keywords: amortized analysis, coinduction, data structure, mechanized proof} }]]> Amortized analysis is a program cost analysis technique for data structures in which the cost of operations is specified in aggregate, under the assumption of continued sequential use. Typically, amortized analyses are presented inductively, in terms of finite sequences of operations. We give an alternative coinductive formulation and prove that it is equivalent to the standard inductive definition. We describe a classic amortized data structure, the batched queue, and outline a coinductive proof of its amortized efficiency in Calf, a dependent type theory for cost analysis. Harrison Grodin Yue Niu Jon Sterling Robert Harper https://calfproject.github.io/grodin-niu-sterling-harper-2024/ grodin-niu-sterling-harper-2024 /grodin-niu-sterling-harper-2024/ Decalf: A Directed, Effectful Cost-Aware Logical Framework Reference POPL ’24: 51st ACM SIGPLAN Symposium on Principles of Programming Languages 10.1145/3632852 2024, title = {Decalf: A Directed, Effectful Cost-Aware Logical Framework}, author = {Grodin, Harrison and Niu, Yue and Sterling, Jonathan and Harper, Robert}, year = {2024}, month = jan, journal = {Proc. ACM Program. Lang.}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, volume = {8}, number = {POPL}, doi = {10.1145/3632852}, url = {https://doi.org/10.1145/3632852}, issue_date = {January 2024}, articleno = {10}, numpages = {29}, keywords = {algorithm analysis, cost models, phase distinction, noninterference, intensional property, behavioral verification, equational reasoning, modal type theory, mechanized proof, proof assistants, recurrence relations, amortized analysis, parallel algorithms} }]]> We present Decalf, a directed, effectful cost-aware logical framework for studying quantitative aspects of functional programs with effects. Like Calf, the language is based on a formal phase distinction between the extension and the intension of a program, its pure behavior as distinct from its cost measured by an effectful step-counting primitive. The type theory ensures that the behavior is unaffected by the cost accounting. Unlike Calf, the present language takes account of effects, such as probabilistic choice and mutable state. This extension requires a reformulation of Calf’s approach to cost accounting: rather than rely on a “separable” notion of cost, here a cost bound is simply another program. To make this formal, we equip every type with an intrinsic preorder, relaxing the precise cost accounting intrinsic to a program to a looser but nevertheless informative estimate. For example, the cost bound of a probabilistic program is itself a probabilistic program that specifies the distribution of costs. This approach serves as a streamlined alternative to the standard method of isolating a cost recurrence and readily extends to higher-order, effectful programs. The development proceeds by first introducing the Decalf type system, which is based on an intrinsic ordering among terms that restricts in the extensional phase to extensional equality, but in the intensional phase reflects an approximation of the cost of a program of interest. This formulation is then applied to a number of illustrative examples, including pure and effectful sorting algorithms, simple probabilistic programs, and higher-order functions. Finally, we justify Decalf via a model in the topos of augmented simplicial sets.