@inproceedings{choudhury2026,
  author = {Choudhury, Vikraman and Wong, Wind},
  title = {Symmetries in {Sorting}},
  booktitle = {31st International Conference on Types for Proofs and
    Programs (TYPES 2025)},
  date = {2026},
  url = {https://doi.org/10.4230/LIPIcs.TYPES.2025.3},
  doi = {10.4230/LIPIcs.TYPES.2025.3},
  langid = {en},
  abstract = {Sorting algorithms are fundamental to computer science,
    and their correctness criteria are well understood as rearranging
    elements of a list according to a specified total order on the
    underlying set of elements. As mathematical functions, they are
    functions on lists that perform combinatorial operations on the
    representation of the input list. In this paper, we study sorting
    algorithms conceptually as abstract sorting functions. There is a
    canonical surjection from the free monoid on a set (lists of
    elements) to the free commutative monoid on the same set (multisets
    of elements). We show that sorting functions determine a section
    (right inverse) to this surjection satisfying two axioms, that do
    not presuppose a total order on the underlying set. Then, we
    establish an equivalence between (decidable) total orders on the
    underlying set and correct sorting functions. The first part of the
    paper develops concepts from universal algebra from the point of
    view of functorial signatures, and gives constructions of free
    monoids and free commutative monoids in (univalent) type theory.
    Using these constructions, the second part of the paper develops the
    axiomatisation of sorting functions. The paper uses informal
    mathematical language, and comes with an accompanying formalisation
    in Cubical Agda.}
}

@inproceedings{blackett2026,
  author = {Blackett, Fiona and Choudhury, Vikraman and Liu, Rin},
  title = {Symmetric {List} {Objects}},
  booktitle = {Eleventh Workshop on Mathematically Structured Functional
    Programming (MSFP 2026)},
  date = {2026},
  url = {https://vikraman.org/papers/blackett-choudhury-liu-2026/},
  langid = {en},
  abstract = {Cons-lists are fundamental to functional programming, and
    are well understood as initial algebras, giving a concrete
    construction of free monoids. This notion of a list object can be
    axiomatised more generally in any monoidal category, replacing the
    cartesian product with a tensor and removing the need for a
    coproduct by axiomatising the nil and cons maps directly via an
    iteration mechanism. Strengthening this to parametrised list objects
    yields a construction of free monoids, and having all parametrised
    list objects makes the forgetful functor from monoids monadic. In
    this talk, we introduce the notion of a symmetric list object in a
    symmetric monoidal category, by imposing an additional axiom
    identifying lists that differ by a transposition of their two
    frontmost elements using the symmetry of the underlying category. We
    show that a list object is symmetric if and only if it is a
    commutative monoid object, if and only if it is the free commutative
    monoid on the underlying object; and that having all parametrised
    symmetric list objects makes the forgetful functor from commutative
    monoids monadic, with the induced monad strong, and further
    commutative when the category is cartesian. Symmetric list objects
    thus give an alternative construction of free commutative monoids in
    a symmetric monoidal category, relevant to the study of the
    exponential modality in linear logic.}
}

@inproceedings{alexandru2025,
  author = {Alexandru, Cass and Choudhury, Vikraman and Rot, Jurriaan
    and van der Weide, Niels},
  title = {Intrinsically {Correct} {Sorting} in {Cubical} {Agda}},
  booktitle = {Certified Programs and Proofs},
  date = {2025},
  url = {https://doi.org/10.1145/3703595.3705873},
  doi = {10.1145/3703595.3705873},
  langid = {en},
  abstract = {The paper “Sorting with Bialgebras and Distributive Laws”
    by Hinze et al. uses the framework of bialgebraic semantics to
    define sorting algorithms. From distributive laws between functors
    they construct pairs of sorting algorithms using both folds and
    unfolds. Pairs of sorting algorithms arising this way include
    insertion/selection sort and quick/tree sort. We extend this work to
    define intrinsically correct variants in cubical Agda. Our key idea
    is to index our data types by multisets, which concisely captures
    that a sorting algorithm terminates with an ordered permutation of
    its input list. By lifting bialgebraic semantics to the indexed
    setting, we obtain the correctness of sorting algorithms purely from
    the distributive law.}
}

@inproceedings{choudhury2025,
  author = {Choudhury, Vikraman and J. Gay, Simon},
  title = {The {Duality} of {λ-Abstraction}},
  booktitle = {Proceedings of the ACM on Programming Languages, Volume
    9, Number POPL},
  date = {2025},
  url = {https://doi.org/10.1145/3704848},
  doi = {10.1145/3704848},
  langid = {en},
  abstract = {In this paper, we develop and study the following
    perspective -\/- just as higher-order functions give exponentials,
    higher-order continuations give coexponentials. From this, we design
    a language that combines exponentials and coexponentials, producing
    a duality of lambda abstraction. We formalise this language by
    giving an extension of a call-by-value simply-typed lambda-calculus
    with covalues, coabstraction, and coapplication. We develop the
    semantics of this language using the axiomatic structure of
    continuations, which we use to produce an equational theory, that
    gives a complete axiomatisation of control effects. We give a
    computational interpretation to this language using speculative
    execution and backtracking, and use this to derive the classical
    control operators and computational interpretation of classical
    logic, and encode common patterns of control flow using
    continuations. By dualising functional completeness, we further
    develop duals of first-order arrow languages using coexponentials.
    Finally, we discuss the implementation of this duality as control
    operators in programming, and develop some applications.}
}

@inproceedings{choudhury2025,
  author = {Choudhury, Vikraman and Krishnaswami, Neel and Si Suo,
    Ariadne},
  title = {Semantic {Analysis} of {Normalisation} for {Directional}
    {Logic} {Programming}},
  booktitle = {Fourth Workshop on the Implementation of Type Systems},
  date = {2025},
  url = {https://vikraman.org/papers/choudhury-krishnaswami-suo-2025/},
  langid = {en},
  abstract = {This work is about using directional logic programming to
    give foundations to mode-correct bidirectional type systems {[}2,
    \textbackslash S 6.2{]}. Reddy{[}5{]} uses a term language for
    classical linear logic, adapted from Abramsky’s Linear Chemical
    Abstract Machine (LCHAM) {[}1{]}, to give a typed calculus for
    directional logic programs. We give a categorical semantics to
    Reddy’s calculus, using polycategories. We give normalisation
    results for this calculus, which shows how to evaluate logic queries
    to normal forms, that gives output substitutions indicating whether
    queries fail or succeed.}
}

@inproceedings{lanese2025,
  author = {Lanese, Ivan and Dal Lago, Ugo and Choudhury, Vikraman},
  title = {Towards {Quantum} {Multiparty} {Session} {Types}},
  booktitle = {Fifth International Workshop on Programming Languages for
    Quantum Computing (PLanQC 2025)},
  date = {2025},
  url = {https://vikraman.org/papers/lanese-lago-choudhury-2025a/},
  langid = {en},
  abstract = {Multiparty Session Types (MPSTs) are a typing discipline
    for message-passing protocols that guarantee communication safety
    properties, such as deadlock-freedom. We propose a quantum extension
    of MPSTs, called Quantum MPSTs (QMPSTs), with the aim of specifying
    quantum protocols. QMPSTs guarantee usual communication safety
    properties, in addition to safety properties specific to quantum
    information, such as no-cloning and no-deleting. We exhibit the use
    of QMP-STs to verify Quantum Teleportation. The full paper (to
    appear in SEFM’24 proceedings) with complete details, metatheoretic
    results, and examples of other quantum protocols is available at
    arXiv:2409.11133 {[}Lanese et al. 2024{]}.}
}

@inproceedings{lanese2024,
  author = {Lanese, Ivan and Dal Lago, Ugo and Choudhury, Vikraman},
  title = {Towards {Quantum} {Multiparty} {Session} {Types}},
  booktitle = {Software Engineering and Formal Methods},
  date = {2024},
  url = {https://doi.org/10.1007/978-3-031-77382-2_22},
  doi = {10.1007/978-3-031-77382-2_22},
  langid = {en},
  abstract = {Multiparty Session Types (MPSTs) offer a structured way of
    specifying communication protocols and guarantee relevant
    communication properties, such as deadlock-freedom. In this paper,
    we extend a minimal MPST system with quantum data and operations,
    enabling the specification of quantum protocols. Quantum MPSTs
    (QMPSTs) provide a formal notation to describe quantum protocols,
    both at the abstract level of global types, describing which
    communications can take place in the system and their dependencies,
    and at the concrete level of local types and quantum processes,
    describing the expected behavior of each participant in the
    protocol. Type-checking relates these two levels formally, ensuring
    that processes behave as prescribed by the global type. Beyond usual
    communication properties, QMPSTs also allow us to prove that qubits
    are owned by a single process at any time, capturing the quantum
    no-cloning and no-deleting theorems. We use our approach to verify
    four quantum protocols from the literature, respectively
    Teleportation, Secret Sharing, Bit-Commitment, and Key
    Distribution.}
}

@inproceedings{wong2024,
  author = {Wong, Wind and Choudhury, Vikraman and J Gay, Simon},
  title = {On {Commutativity,} {Total} {Orders,} and {Sorting}},
  booktitle = {Workshop on Homotopy Type Theory / Univalent Foundations
    (HoTT/UF 2024)},
  date = {2024},
  url = {https://vikraman.org/papers/wong-choudhury-gay-2024/},
  langid = {en},
  abstract = {In this talk, we study free monoids, free commutative
    monoids, and their connections with sorting and well-orders.
    Univalent type theory provides a rigorous framework for implementing
    these ideas, in the construction of free algebras using higher
    inductive types and quotients, and reasoning up to equivalence using
    categorical universal properties. The main contributions are a new
    framework for universal algebra (free algebras and their universal
    properties), various constructions of free monoids and free
    commutative monoids (with proofs of their universal properties),
    applications to proving combinatorial properties of these
    constructions, and finally an axiomatic understanding of sorting.
    Our results have been formalized in Cubical Agda, and the
    formalization is available at:
    https://github.com/pufferffish/agda-symmetries/.}
}

@inproceedings{choudhury2023,
  author = {Choudhury, Vikraman and J. Gay, Simon},
  title = {Classical {Processes} in {Modern} {Dress}},
  booktitle = {30 Years of Session Types},
  date = {2023},
  url = {https://vikraman.org/papers/choudhury-gay-2023/},
  langid = {en}
}

@phdthesis{choudhury2023,
  author = {Choudhury, Vikraman},
  title = {Mathematical {Models} of {Resource-Conscious} {Computation}},
  date = {2023},
  url = {https://vikraman.org/papers/choudhury-2023/},
  langid = {en},
  abstract = {This thesis studies various logics and programming
    languages for resource-conscious computation, in particular, their
    syntax, categorical and denotational semantics, and presents a
    collection of results. Firstly, we study the construction of free
    commutative monoids in univalent type theory, and their structural
    combinatorial properties. We give a formal construction of the
    relational model of classical linear logic, and use free commutative
    monoids to construct the comonadic exponential modality. Relating
    this to the combinatorial Fock space construction and associated
    creation/annihilation operators, we exhibit the differential
    structure of this relation model. From this, we derive a commutation
    relation characterising the path space of free commutative monoids.
    Secondly, we groupoidify and study free symmetric monoidal groupoids
    and free symmetric rig groupoids. These are used to build a family
    of high-level programming languages for reversible computing, giving
    them an equational theory stemming from the categorical coherence
    conditions. We then give a denotational semantics to this family of
    languages, using deloopings of symmetric groups, and obtain a
    fully-complete denotational semantics using the groupoid of finite
    sets and bijections, with its additive and multiplicative monoidal
    structure. This establishes a Curry-Howard-Lambek correspondence for
    reversible computing with finite number of bits. We show some
    applications of this semantics to perform
    normalisation-by-evaluation, verification, and synthesis of
    reversible boolean circuits, motivated by examples from quantum
    computing. Thirdly, we study capability-safe programming, using an
    effectful simply-typed lambda calculus. We give a denotational
    semantics to this language by building a capability-space model,
    which formalises the notion of capability-safety. We identify its
    axiomatic categorical structure and use this to justify the
    equational theory of the language. Using this semantics, we
    construct a comonadic modality expressing capability denial, and use
    it to extend the syntax of our language. We show that this modality
    allows one to recover pure computation in an otherwise impure
    language.}
}

@inproceedings{choudhury2023,
  author = {Choudhury, Vikraman and Fiore, Marcelo},
  title = {Free {Commutative} {Monoids} in {Homotopy} {Type} {Theory}},
  booktitle = {Electronic Notes in Theoretical Informatics and Computer
    Science},
  date = {2023},
  url = {https://doi.org/10.46298/entics.10492},
  doi = {10.46298/entics.10492},
  langid = {en},
  abstract = {We develop a constructive theory of finite multisets in
    Homotopy Type Theory, defining them as free commutative monoids.
    After recalling basic structural properties of the free
    commutative-monoid construction, we formalise and establish the
    categorical universal property of two, necessarily equivalent,
    algebraic presentations of free commutative monoids using 1-HITs.
    These presentations correspond to two different equational theories
    invariably including commutation axioms. In this setting, we prove
    important structural combinatorial properties of finite multisets.
    These properties are established in full generality without assuming
    decidable equality on the carrier set. As an application, we present
    a constructive formalisation of the relational model of classical
    linear logic and its differential structure. This leads to
    constructively establishing that free commutative monoids are
    conical refinement monoids. Thereon we obtain a characterisation of
    the equality type of finite multisets and a new presentation of the
    free commutative-monoid construction as a set-quotient of the list
    construction. These developments crucially rely on the commutation
    relation of creation/annihilation operators associated with the free
    commutative-monoid construction seen as a combinatorial Fock space.}
}

@inproceedings{choudhury2024,
  author = {Choudhury, Vikraman and Agapiev, Borislav and Sabry, Amr},
  title = {Scheme {Pearl:} {Quantum} {Continuations}},
  booktitle = {Scheme and Functional Programming Workshop},
  date = {2024},
  url = {https://doi.org/10.48550/arXiv.2409.11106},
  doi = {10.48550/arXiv.2409.11106},
  langid = {en},
  abstract = {We advance the thesis that the simulation of quantum
    circuits is fundamentally about the efficient management of a large
    (potentially exponential) number of delimited continuations. The
    family of Scheme languages, with its efficient implementations of
    first-class continuations and with its imperative constructs,
    provides an elegant host for modeling and simulating quantum
    circuits.}
}

@inproceedings{choudhury2022,
  author = {Choudhury, Vikraman and Karwowski, Jacek and Sabry, Amr},
  title = {Symmetries in Reversible Programming},
  booktitle = {Proceedings of the ACM on Programming Languages},
  date = {2022},
  url = {https://doi.org/10.1145/3498667},
  doi = {10.1145/3498667},
  langid = {en},
  abstract = {The Pi family of reversible programming languages for
    boolean circuits is presented as a syntax of combinators witnessing
    type isomorphisms of algebraic data types. In this paper, we give a
    denotational semantics for this language, using weak groupoids à la
    Homotopy Type Theory, and show how to derive an equational theory
    for it, presented by 2-combinators witnessing equivalences of type
    isomorphisms. We establish a correspondence between the syntactic
    groupoid of the language and a formally presented univalent
    subuniverse of finite types. The correspondence relates
    1-combinators to 1-paths, and 2-combinators to 2-paths in the
    universe, which is shown to be sound and complete for both levels,
    forming an equivalence of groupoids. We use this to establish a
    Curry-Howard-Lambek correspondence between Reversible Logic,
    Reversible Programming Languages, and Symmetric Rig Groupoids, by
    showing that the syntax of Pi is presented by the free symmetric rig
    groupoid, given by finite sets and bijections. Using the
    formalisation of our results, we perform
    normalisation-by-evaluation, verification and synthesis of
    reversible logic gates, motivated by examples from quantum
    computing. We also show how to reason about and transfer theorems
    between different representations of reversible circuits.}
}

@inproceedings{choudhury2020,
  author = {Choudhury, Vikraman and Krishnaswami, Neel},
  title = {Recovering Purity with Comonads and Capabilities},
  booktitle = {Proceedings of the ACM on Programming Languages},
  date = {2020},
  url = {https://doi.org/10.1145/3408993},
  doi = {10.1145/3408993},
  langid = {en},
  abstract = {In this paper, we take a pervasively effectful (in the
    style of ML) typed lambda calculus, and show how to extend it to
    permit capturing pure expressions with types. Our key observation is
    that, just as the pure simply-typed lambda calculus can be extended
    to support effects with a monadic type discipline, an impure typed
    lambda calculus can be extended to support purity with a comonadic
    type discipline. We establish the correctness of our type system via
    a simple denotational model, which we call the capability space
    model. Our model formalises the intuition common to systems
    programmers that the ability to perform effects should be controlled
    via access to a permission or capability, and that a program is
    capability-safe if it performs no effects that it does not have a
    runtime capability for. We then identify the axiomatic categorical
    structure that the capability space model validates, and use these
    axioms to give a categorical semantics for our comonadic type
    system. We then give an equational theory (substitution and the
    call-by-value β and η laws) for the imperative lambda calculus, and
    show its soundness relative to this semantics. Finally, we give a
    translation of the pure simply-typed lambda calculus into our
    comonadic imperative calculus, and show that any two terms which are
    βη-equal in the STLC are equal in the equational theory of the
    comonadic calculus, establishing that pure programs can be mapped in
    an equation-preserving way into our imperative calculus.}
}

@inproceedings{chen2020,
  author = {Chen, Chao-Hong and Choudhury, Vikraman and Carette, Jacques
    and Sabry, Amr},
  title = {Fractional {Types}},
  booktitle = {Reversible Computation - 12th International Conference,
    RC 2020, Oslo, Norway, July 9-10, 2020, Proceedings},
  date = {2020},
  url = {https://doi.org/10.1007/978-3-030-52482-1_10},
  doi = {10.1007/978-3-030-52482-1_10},
  langid = {en}
}

@inproceedings{carette2018,
  author = {Carette, Jacques and Chen, Chao-Hong and Choudhury, Vikraman
    and Sabry, Amr},
  title = {From {Reversible} {Programs} to {Univalent} {Universes} and
    {Back}},
  booktitle = {Electronic Notes in Theoretical Computer Science},
  date = {2018},
  url = {https://doi.org/10.1016/j.entcs.2018.03.013},
  doi = {10.1016/j.entcs.2018.03.013},
  langid = {en},
  abstract = {We establish a close connection between a reversible
    programming language based on type isomorphisms and a formally
    presented univalent universe. The correspondence relates combinators
    witnessing type isomorphisms in the programming language to paths in
    the univalent universe; and combinator optimizations in the
    programming language to 2-paths in the univalent universe. The
    result suggests a simple computational interpretation of paths and
    of univalence in terms of familiar programming constructs whenever
    the universe in question is computable.}
}

@inproceedings{vazou2017,
  author = {Vazou, Niki and Tondwalkar, Anish and Choudhury, Vikraman
    and G. Scott, Ryan and R. Newton, Ryan and Wadler, Philip and Jhala,
    Ranjit},
  title = {Refinement Reflection},
  booktitle = {Proceedings of the ACM on Programming Languages},
  date = {2017},
  url = {https://doi.org/10.1145/3158141},
  doi = {10.1145/3158141},
  langid = {en},
  abstract = {We introduce Refinement Reflection, a new framework for
    building SMT-based deductive verifiers. The key idea is to reflect
    the code implementing a user-defined function into the function’s
    (output) refinement type. As a consequence, at uses of the function,
    the function definition is instantiated in the SMT logic in a
    precise fashion that permits decidable verification. Reflection
    allows the user to write equational proofs of programs just by
    writing other programs using pattern-matching and recursion to
    perform case-splitting and induction. Thus, via the
    propositions-as-types principle, we show that reflection permits the
    specification of arbitrary functional correctness properties.
    Finally, we introduce a proof-search algorithm called Proof by
    Logical Evaluation that uses techniques from model checking and
    abstract interpretation, to completely automate equational
    reasoning. We have implemented reflection in Liquid Haskell and used
    it to verify that the widely used instances of the Monoid,
    Applicative, Functor, and Monad typeclasses actually satisfy key
    algebraic laws required to make the clients safe, and have used
    reflection to build the first library that actually verifies
    assumptions about associativity and ordering that are crucial for
    safe deterministic parallelism.}
}

@inproceedings{chen2017,
  author = {Chen, Chao-Hong and Choudhury, Vikraman and R. Newton, Ryan},
  title = {Adaptive Lock-Free Data Structures in {Haskell}},
  booktitle = {Proceedings of the 10th ACM SIGPLAN International
    Symposium on Haskell, Oxford, United Kingdom, September 7-8, 2017},
  date = {2017},
  url = {https://doi.org/10.1145/3122955.3122973},
  doi = {10.1145/3122955.3122973},
  langid = {en}
}

@misc{scott2017,
  author = {Scott, Ryan and Choudhury, Vikraman and Newton, Ryan and
    Vazou, Niki and Jhala, Ranjit},
  title = {Deriving {Law-Abiding} {Instances}},
  date = {2017},
  url = {https://doi.org/10.48550/arXiv.1708.02328},
  doi = {10.48550/arXiv.1708.02328},
  langid = {en},
  abstract = {Liquid Haskell’s refinement-reflection feature augments
    the Haskell language with theorem proving capabilities, allowing
    programmers to retrofit their existing code with proofs. But many of
    these proofs require routine, boilerplate code that is tedious to
    write. Moreover, many such proofs do not scale well, as the size of
    proof terms can grow superlinearly with the size of the datatypes
    involved in the proofs. We present a technique for programming with
    refinement reflection which solves this problem by leveraging
    datatype-generic programming. Our observation is that we can take
    any algebraic datatype, generate an equivalent representation type,
    and have Liquid Haskell automatically construct (and prove) an
    isomorphism between the original type and the representation type.
    This reduces many proofs down to easy theorems over simple algebraic
    “building block” types, allowing programmers to write generic proofs
    cheaply and cheerfully.}
}

@misc{carette2016,
  author = {Carette, Jacques and Chen, Chao-Hong and Choudhury, Vikraman
    and Sabry, Amr},
  title = {Fractional {Types}},
  date = {2016},
  url = {https://vikraman.org/papers/carette-chen-choudhury-sabry-2016/},
  langid = {en}
}