Bahr, Patrick

Mannaa, Bassel

Møgelberg, Rasmus Ejlers

We give an overview of the syntax and semantics of Clocked Type Theory (CloTT), a dependent type theory for guarded recursion with many clocks, in which one can encode coinductive types and capture the notion of productivity in types. The main novelty of CloTT is the notion of ticks, which allows one to open the delay type modality, and, e.g., define a dependent form of applicative functor action, which can be used for reasoning about coinductive data. In the talk we will give examples of programming and reasoning about guarded recursive and coinductive data in CloTT, and we will present the main syntactic results: Strong normalisation, canonicity and decidability of type checking. If time permits, we will also sketch the main ideas of the denotational semantics for CloTT

The IT University of Copenhagen's Repository

What makes guarded types tick?Patrick Bahr, Bassel Mannaa, and Rasmus Ejlers MøgelbergIT University of Copenhagen (paba,basm,mogel@itu.dk)AbstractWe give an overview of the syntax and semantics of Clocked Type Theory (CloTT), adependent type theory for guarded recursion with many clocks, in which one can encodecoinductive types and capture the notion of productivity in types. The main novelty ofCloTT is the notion of ticks, which allows one to open the delay type modality, and, e.g.,define a dependent form of applicative functor action, which can be used for reasoningabout coinductive data. In the talk we will give examples of programming and reasoningabout guarded recursive and coinductive data in CloTT, and we will present the mainsyntactic results: Strong normalisation, canonicity and decidability of type checking. Iftime permits, we will also sketch the main ideas of the denotational semantics for CloTT.The results presented in this talk have previously been published in [2, 5].Guarded recursionThe idea of guarded recursion [6], is to ensure productivity of recursive definitions by guardingall recursive calls by a delay type modality . (pronounced later). We think of .A as classifyingdata of type A that is available one time step from now. The assumptions on . are a termnext : A → .A and a fixed point operator fix : (.A → A) → A. The latter can be used incombination with guarded recursive types to define recursive programs. Suppose for example,that Str is a type of guarded streams satisfying the type equation Str ≡ N×.Str. One can thendefine a constant stream of zeros as fix(λx. (0, x)). For higher order programming with guardedstreams, one needs to assume that . is an applicative functor, with applicative action~ : .(A→ B)→ .A→ .BFor example, given f : N→ N one can define map f : Str→ Str asfix(λg.λ (x, xs) . (f(x), g ~ xs))TicksSuppose now, that we want to reason about guarded streams using guarded recursion. Asa simple motivating example, suppose we are given some predicate on N in the form of adependent type x : N ` P (x) type. A lifting of P to guarded streams should be a dependenttype xs : Str ` Pˆ (xs) type satisfying Pˆ (x, xs) iff P (x) and “Pˆ (xs)”. However, the latterstatement is not well typed, since xs has type .Str and Pˆ expects an element of Str. Rather,it should be true that one time step from now, Pˆ holds of the stream delivered at that time byxs. Ticks are evidence that time has passed, and they allow us to open elements of type .A.The rules for ticks can be described in a small dependently typed tick calculus:Γ `Γ, α:tick `Γ, α:tick ` AΓ ` .(α:tick)AΓ, α:tick ` t : AΓ ` λ(α:tick)t : .(α:tick)AΓ ` t : .(α:tick)AΓ, β:tick,Γ′ ` t [β] : A[β/α]What makes guarded types tick? Bahr, Mannaa and MøgelbergA tick in a context Γ, β:tick,Γ′ can be thought of as dividing the context into variables (Γ),that arrive before the tick, and variables (Γ′) that arrive after. The rule for tick applicationt [β] can be thought of as stating that t must be typed already before the tick β occurs. Wewrite .A for .(α:tick).A whenever α does not occur in A, and similarly next t for λ(α:tick).twhenever α does not occur in A.The requirement for the lifting Pˆ can now be described as Pˆ (x, xs) ≡ P (x)× .(α:tick)Pˆ (xs[α]).Moreover, one can generalise the applicative action to dependent types as follows:λf.λy.λ(α:tick).f [α](y [α]) : . (∏(x : A) .B)→∏ (y : .A) . . (α:tick).B[y [α]/x]We can now use fix also for reasoning. For example a proof p : Π(x:N)P can be lifted to a proofof Π(y:Str)Pˆ (y) as follows: Consider firstf : .(Π(y:Str)Pˆ (y))→ Π(y:Str)Pˆ (y)f q ((x, xs))def= (p(x), λ(α:tick)q [α](xs [α]))then fix(f) : Π(y:Str)Pˆ (y).Clocked Type TheoryThe goal of Clocked Type Theory (CloTT) is to allow programming and reasoning with guardedrecursive types but also with coinductive types. In order to work with coinductive types,CloTT combines ticks with multiple clocks and clock quantification as pioneered by Atkey &McBride [1]. To this end, the typing judgement includes a clock context ∆, which is a finite setof clocks. Moreover, each tick belongs to a clock κ; instead of α:tick, we write α:κ to indicatethat α is a tick on the clock κ. Correspondingly, the later modality is written as .(α:κ).A andwe write .κA if α does not appear in A. The type of guarded streams over clock κ then becomesStrκ, satisfying Strκ ≡ N× .κStrκ.For guarded streams, we can construct head and tail functions as follows:hdκ : Strκ → Nhdκdef= λx : Strκ.pi1 xtlκ : Strκ → .κ Strκtlκdef= λx : Strκ.λ(α:κ).(pi2 x) [α]We can use them to get the second element of a stream like this:λ(xs : Strκ).λ(α:κ).hdκ(tlκ xs [α]) : Strκ → .κNNote that the result type is .κN as opposed to N. To get the second element of the stream asa term of type N we have to consider coinductive streams.To form coinductive types, we use clock quantification ∀κ.A. An element of type ∀κ.A is aterm of type A that can compute for an arbitrary number of ticks on clock κ. This intuition isrealised in CloTT by the addition of a tick constant  : κ, for any clock κ. The tick constant can be used arbitrarily often for a term of type ∀κ.A, which is expressed in the typing rule fortick constant application t []:Γ `∆,κ t : A Γ `∆Γ `∆ Λκ.t : ∀κ.AΓ `∆ t : ∀κ.A κ′ ∈ ∆Γ `∆ t[κ′] : A[κ′/κ]Γ `∆,κ t : . (α:κ).A Γ `∆Γ `∆,κ t [] : A [/α]For the consistency of the calculus it is crucial that the typing rule for t [] requires the clockκ to be fresh for the context Γ. While this rule provides sufficient expressivity of the calculus,2What makes guarded types tick? Bahr, Mannaa and Møgelbergthe rule has to be generalised slightly in order to obtain standard syntactic properties such asclosure under substitution and subject reduction.Γ `∆,κ t : . (α:κ).A Γ `∆ κ′ ∈ ∆Γ `∆ (t [κ′/κ]) [] : A[κ′/κ] [/α]In this more general rule, the clock κ is substituted away in the conclusion.Given the type of guarded streams Strκ over κ, we can construct the type of coinductivestreams by a simple clock quantification: Strcdef= ∀κ.Strκ. Returning to the example of obtainingthe second element of a stream, the coinductive type allows us to get that second element ofthe stream of type N, because we may use the tick constant :hd : Strc → Nhddef= λx : Str.hdκ0 (x [κ0])tl : Strc → Strctldef= λx : Strc.Λκ.(tlκ (x [κ])) []λ(xs : Strc).hd(tlxs) : Strc → NReduction semanticsThe main motivation for introducing ticks is to be able to compute with guarded recursive de-pendent types. Bizjak et al. [4] introduced delayed substitutions as a means to combine guardedtypes with dependent types. However, delayed substitutions turn out to be inappropriate fordevising a reduction semantics. With ticks, computations on later types can be expressed asstraightforward beta and eta reductions:(λ(α:κ).t) [α′]→ t [α′/α] λ(α:κ).(t [α])→ t(Λκ.t)[κ′]→ t[κ′/κ] (Λκ.t[κ])→ tHowever, this still leaves us with the fixed point combinator fixκ : (.κA → A) → A. Al-lowing arbitrary unfolding of fixed points by adding the rule fixκ t → t(nextκ (fixκ t)), wouldimmediately yield a non-normalising reduction system.Instead, we introduce a combinator dfixκ : (.κA→ A)→ .κA as a primitive and derive fixκfrom it by defining fixκdef= λx.x(dfixκ x). Since a term dfixκt is of type .κA rather than A, weare not forced to unfold dfixκ for the sake of canonicity. We only have to unfold it if that termis applied to the tick constant  and thus forms a term of type A:(dfixκ t) []→ t (dfixκ t)With the above rule we still maintain canonicity since any term (dfixκ t) [α], where α is a tickvariable, is considered an open term. Moreover, the rule is restricted enough to ensure strongnormalisation:Theorem 1 (Strong normalisation & canonicity).1. If Γ `∆ t : A, then t is strongly normalising.2. If `∆ t : N, then t→∗ sucn 0 for some n ∈ N.Since the reduction semantics is confluent as well, we also obtain a decision procedure forthe equational theory of the calculus. Details of CloTT and its reduction semantics can befound in Bahr et al. [2].3What makes guarded types tick? Bahr, Mannaa and MøgelbergDenotational semanticsIf time permits, we will also discuss the denotational semantics of CloTT. Dependent typetheory with guarded recursion on a single clock can be given a denotational semantics in thetopos of trees [3], modelling a closed type as a family of sets Xn indexed by natural numbers,together with restriction maps rnX : Xn+1 → Xn for each n. The delay type operator is modelledas (.X)0 = 1 (the singleton set) and (.X)n+1 = Xn. This allows the fixed point operator to bemodelled using natural number induction. For example, the type of guarded streams satisfyingStr ≡ N × .Str can be modelled as Strn = Nn+1 × 1 (associating the products to the right forstrict equality of types), and the lifting of P satisfying Pˆ (x, xs) ≡ P (x)× .(α:tick)Pˆ (xs[α])can be modelled asPˆ (xn, (xn−1, . . . , (x0, ?) . . . ) = {(pn, (pn−1, . . . , (p0, ?) . . . ) | ∀i.pi ∈ P (xi)}There is no object of ticks in this model. Instead, ticks in contexts are modelled using the leftadjoint / to . defined as (/X)n = Xn+1 by defining JΓ, α : tickK = /JΓK. The multiclock case ismore complex, but follows the same pattern: To model clocks, one needs a category with family(a standard notion of model of dependent type theory), an adjunction of endofunctors L a Ron the underlying category, an extension of R to types and terms, and a projection L → id tomodel tick weakening. The details of this model can be found in [5].References[1] R. Atkey and C. McBride. Productive coprogramming with guarded recursion. In ICFP, pages197–208. ACM, 2013.[2] P. Bahr, H. B. Grathwohl, and R. E. Møgelberg. The clocks are ticking: No more delays! In LICS,pages 1–12. IEEE, 2017.[3] L. Birkedal, R. E. Møgelberg, J. Schwinghammer, and K. Støvring. First steps in synthetic guardeddomain theory: step-indexing in the topos of trees. Logical Methods in Computer Science, 8(4),2012.[4] A. Bizjak, H. B. Grathwohl, R. Clouston, R. E. Møgelberg, and L. Birkedal. Guarded dependenttype theory with coinductive types. In FOSSACS, pages 20–35, 2016.[5] Bassel Mannaa and Rasmus Ejlers Møgelberg. The clocks they are adjunctions: Denotationalsemantics for clocked type theory. arXiv preprint arXiv:1804.06687, 2018.[6] H. Nakano. A modality for recursion. In LICS, pages 255–266. IEEE, 2000.4

What makes guarded types tick?

https://pure.itu.dk/ws/files/83193673/abstract.pdf

What makes guarded types tick?

Abstract

Similar works

Full text

Available Versions

The IT University of Copenhagen's Repository