MFPS 2018 Program

All MFPS talks will be held in room 1009 of the Kenneth C. Rowe Management building at 6100 University Avenue (building E260 on the campus map). QPL talks are in room 1020 of the same building.

Wednesday, June 6, 2018

(See also the program of QPL 2018, held in parallel).

9:00–10:30 MFPS participants are welcome to attend the QPL invited lecture and first session
10:30–11:00 Coffee break
11:00-11:30 Naohiko Hoshino Partial traces on additive categories [pdf]
11:30–12:00 Chris Heunen, Robin Kaarsgaard and Martti Karvonen Reversible effects as inverse arrows [pdf]
12:00–12:30 Thomas Cottrell, Soichiro Fujii and John Power Higher dimensional categories: recursion on extensivity [pdf]
12:30–2:00 Lunch break

Special session on quantum programming, joint with QPL 2018

2:00–3:00 Invited lecture Neil J. Ross Proto-Quipper: A circuit description language for quantum computing [abstract]

Quipper is a functional programming language for quantum computation which has been used to implement various elaborate quantum algorithms. At the moment, Quipper is implemented as an embedded language, whose host language is Haskell. One of the disadvantages to Quipper being an embedded language is that the Haskell type system, while providing many type-safety properties, is not in general strong enough to ensure the full type-safety of quantum programs.

The Proto-Quipper language provides a foundation for the development of a stand-alone (i.e., non-embedded) version of Quipper. Like Quipper, Proto-Quipper acts as a circuit description language and provides the ability to treat circuits as data in order to manipulate them as a whole. However, Proto-Quipper is also designed to “enforce the physics”, in the sense that its type system would detect, at compile-time, programming errors that could lead to ill-formed or undefined circuits.

I will start my talk with a brief introduction to quantum computing and a discussion of the design principles behind Quipper. I will then present Proto-Quipper and discuss open problems.

3:00–3:30 Benoît Valiron On quantum and classical control [abstract]

One perspective on quantum algorithms is that they are classical algorithms having access to a special kind of memory with exotic properties. This perspective suggests that, even in the case of quantum algorithms, the control flow notions of sequencing, conditionals, loops, and recursion are entirely classical. There is however, another notion of control flow, that is itself quantum. The notion of quantum conditional expression is reasonably well-understood: the execution of the two expressions becomes itself a superposition of executions. The quantum counterpart of loops and recursion is however still unclear. In this talk, we argue that, under the right circumstances, a reasonable notion of quantum loops and recursion is possible. To this aim, we first propose a classical, typed, reversible language with lists and fixpoints. We then extend this language to the closed quantum domain (without measurements) by allowing linear combinations of terms and restricting fixpoints to structurally recursive fixpoints whose termination proofs match the proofs of convergence of sequences in infinite-dimensional Hilbert spaces. We additionally give an operational semantics for the quantum language in the spirit of algebraic lambda-calculi.

The talk will be based on arXiv:1804.00952.

3:30–4:00 Coffee break
4:00–4:30 Jennifer Paykin Preaching to the QWIRE: Verified semantics of quantum circuits [abstract]

Embedded quantum circuit languages like Quipper, LiQUi|⟩, and ProjectQ let programmers express high-level algorithms using host language libraries and features like recursion and data structures. But how can we verify the correctness of embedded quantum circuits without reasoning about the semantics of the entire host language? QWIRE (pronounced “choir”) is a quantum circuit language embedded in Coq, a dependently-typed programming language and interactive theorem prover. QWIRE both has the benefits of an embedded language and can be formally verified inside Coq itself. In this talk I will present the theory and semantics of QWIRE and show how to formally verify the correctness of quantum programs using QWIRE’s denotational semantics.

4:30–5:00 Vadym Kliuchnikov Tasks performed by programming languages for quantum computers and how Q# enables them [abstract]

We will discuss the requirements for programming languages for quantum computers and highlight the differences with programming languages for classical computers. Then we will see how these new requirements are addressed in Q#. This talk will also serve as an introduction to Q#.

5:00–5:30 Craig Gidney Optimizing quantum circuits with classical thinking [abstract]

Although quantum computing is now a decades-old field, there are still many low-hanging opportunities for improving the projected costs of quantum algorithms by orders of magnitude. For example, when designing an efficient quantum algorithm one can often identify nearly-classical subproblems. Efficient classical circuits for these subproblems translate into efficient quantum circuits for the original algorithm.

This talk will discuss a concrete example of the quantum-to-classical-and-back approach bearing fruit. I will show that preparing a particular type of superposition is equivalent to fitness proportionate selection (a classical task where one has a population of items with associated fitnesses and wishes to sample items with twice as much fitness twice as often). I will then explain an efficient classical algorithm for fitness proportionate selection, and translate it back into the quantum domain to produce the 'subprepare' oracle from arXiv:1805.03662, which prepares (and unprepares) superpositions with hardcoded coefficients 100x more efficiently than previous work.

5:30–10:00 Reception and conference dinner. University Club, 6259 Alumni Crescent (building C440 on the campus map)

Thursday, June 7, 2018

(See also the program of QPL 2018, held in parallel).

9:00–10:00 MFPS participants are welcome to attend the QPL invited lecture
10:00–10:30 Richard Blute, Robin Cockett, Pierre-Alain Jacqmin and Philip Scott Finiteness spaces and generalized power series [pdf]
10:30–11:00 Coffee break
11:00–11:30 Hugo Paquet and Glynn Winskel Continuous probability distributions in concurrent games [pdf]
11:30–12:00 Paul Blain Levy and Nathan Bowler Initial algebras and final coalgebras consisting of nondeterministic finite trace strategies [pdf]
12:00–12:30 Jules Hedges Morphisms of open games [pdf]
12:30–2:00 Lunch break

Special session on session types

2:00–3:00 Invited lecture Frank Pfenning Ergometric and Temporal Session Types [abstract]

[joint work with Ankush Das and Jan Hoffmann]

We usually analyze sequential programs in terms of time and space complexity. For concurrent programs, there are richer sets of quantities of interest. For example, in fork/join parallelism we analyze work (that is, the total number of operations) and span (that is, time under the assumption of maximal parallelism). Other measures of interest include latency and throughput of pipelines and response times for interactive systems.

In this talk we show how to extend a system of basic session types for message-passing concurrent processes to capture various aspects of parallel complexity. In particular, we introduce ergometric session types to measure work and temporal session types to measure time. Work and time remain abstract in the sense that we can support different concrete cost models in the same framework. We illustrate our approach via simple examples of message-passing concurrent programs with their types.

Session types can be viewed as arising from a computational interpretation of linear logic where cut reduction in the sequent calculus corresponds to communication. We provide a preliminary assessment of how well ergometric and temporal types fit with this logical foundation.

3:00–3:30 Simon Fowler Session Types without Tiers [abstract]

Session types statically guarantee that communication complies with a protocol. However, most accounts of session typing do not account for failure, which means they are of limited use in real applications---especially distributed applications---where failure is pervasive.

We present the first formal integration of asynchronous session types with exception handling in a functional programming language. We define a core calculus which satisfies preservation and progress properties, is deadlock free, confluent, and terminating.

We provide the first implementation of session types with exception handling for a fully-fledged functional programming language, by extending the Links web programming language; our implementation draws on existing work on algebraic effects and effect handlers.

3:30–4:00 Coffee break
4:00–4:30 Rumyana Neykova A Session Type Provider: Compile-time Generation of Session Types with Interaction Refinements [abstract]

Session types is a typing discipline for concurrent and distributed processes that allows errors such as communication mismatches and deadlocks to be detected statically. Refinement types are types elaborated by logical constraints that allow richer and finer-grained specification of application properties, combining types with logical formulae that may refer to program values and can constrain types using arbitrary predicates. Type providers, developed in F#, are compile-time components for on-demand code generation. Their architecture relies on an open-compiler, where provider-authors implement a small interface that allows them to inject new names/types into the programming context as the program is written.

In this talk, I will present a library that integrates aspects from the above fields to realise practical applications of multiparty refinement session types (MPST) for any .Net language. Our library supports the specification and validation of distributed message passing protocols based on a formulation of asynchronous MPST enriched with interaction refinements: a collection of features related to the refinement of protocols, such as message-type refinements (value constraints) and value dependent control flow. The combination of these aspects—session types for structured interactions, constraint solving from refinement types, and protocol-specific code generation—enables the specification and implementation of enriched protocols in native F# (and any .Net-compiled language) without requiring language extensions or external pre-processing of user programs. A well-typed endpoint program using our library is guaranteed to perform only compliant session I/O actions w.r.t. to the refined protocol, up to premature termination. The safety guarantees are achieved by a combination of static type checking of the generated types for messages and I/O operations, correctness by construction from code generation, and automated inlining of assertions.

4:30–5:00 Bernardo Toninho Depending on Session-Typed Processes [abstract]

Session types are a typing discipline for message-passing concurrency that enables the specification of communication protocols as channel types, which can then be statically and/or dynamically enforced in order to ensure various correctness properties such as deadlock-freedom and protocol compliance.

However, in most session typing frameworks the language of types (and so, the language of protocols) is kept fairly limited, consisting mainly of sequential descriptions of input and output actions, combined with some form of branching or alternative behaviours.

In this talk I will present a dependent type theory, realised in a concurrent functional language based on the Curry-Howard interpretation of linear logic, that allows for session processes to depend on functions and vice-versa, as well as for the definition of type-level functions. By enriching the type language in this way, we are able to specify protocols where the choice of the next communication action can truly depend on the specific values of exchanged data -- a significant gain in expressiveness wrt the state of the art. I will also show how the type theoretic nature of the framework allows us to internally describe and prove predicates on process behaviours, akin to dependently-typed specifications of functional programs.

Finally, in order to both justify some of our design choices and to benchmark the expressiveness of the theory I will introduce a faithful embedding (up-to the theory's internal equality) of the functional layer of the calculus within the session-typed process layer.

Contributed paper

5:00–5:30 Tarmo Uustalu, Niccolò Veltri and Noam Zeilberger The sequent calculus of skew monoidal categories [pdf]

Friday, June 8, 2018

Special session on differentiable programming

9:00–10:00 Invited lecture Gordon Plotkin A Simple Differential Programming Language
10:00–10:30 Matthijs Vakar Diffeological Spaces and Denotational Semantics for Differential Programming
10:30–11:00 Coffee break
11:00-11:30 Marie Kerjean A logic of Linear Partial Differential Equations
11:30–12:00 Barak Pearlmutter Stumbling Blocks on the Road to Differentiable Programming [abstract]

We are entering a magical era, as everything around us becomes responsive and adaptive. To make this happen, it needs to be easy to make computer programs adapt, and the main road we see ahead is differentiable programming: being able to compute and derivatives (primarily gradients) of arbitrary programs. These differentiation operators should be first class: general, robust, performant, and deeply embedded in compilers. I will discuss some subtle difficulties that arise, which have two main causes: approximation, and use of an explicit basis. Both seem unavoidable when building practical systems, and these issues will only become more prominent as our systems grow in complexity.

Contributed paper

12:00–12:30 Robin Cockett and Jean-Simon Lemay Cartesian integral categories and contextual integral categories [pdf]
12:30–2:00 Lunch break
2:00–2:30 Fredrik Dahlqvist, Vincent Danos, Ilias Garnier and Alexandra Silva Borel kernels and their approximation, categorically [pdf]
2:30–3:00 Tobias Fritz and Paolo Perrone Bimonoidal structure of probability monads [pdf]
3:00–3:30 Pieter Hofstra, Jason Parker and Philip Scott Isotropy of algebraic theories [pdf]
3:30–4:00 Coffee break
4:00–4:30 Ohad Kammar and Dylan McDermott Factorisation systems for logical relations and monadic lifting in type-and-effect system semantics [pdf]
4:30–5:00 Bartek Klin and Julian Salamanca Iterated covariant powerset is not a monad [pdf]
5:00–5:30 Ernie Manes and Philip Mulry Near distributive laws [pdf]

Saturday, June 9, 2018

Special session on gradual typing

9:00–10:00 Invited lecture Ronald Garcia Gradual Enforcement of Program Invariants
10:00–10:30 Joshua Dunfield Uncertainty is Hope: logic and gradual typing
10:30–11:00 Coffee break
11:00-11:30 Max New Semantic Foundations for Gradual Typing

Contributed papers

11:30–12:00 Yuichi Nishiwaki, Yoshihiko Kakutani and Yuito Murase Modality via iterated enrichment [pdf]
12:30 Close