<div dir="ltr"><div class="gmail_default" style="font-family:arial,helvetica,sans-serif"><div dir="ltr"><div dir="ltr"><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">So, I thought about this a while longer.</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif"><br></div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">One thing to note is that you can avoid the coinductive proof working</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">(I think) by making the argument to step inductive like so:</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif"><br></div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">    data Delay A where</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">      now : A -> Delay A</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">      later : Delay' A -> Delay A</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">      step : ∀ d -> later (delay d) ≡ d -- delay d .force = d<br></div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif"><br></div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">This still implies `later ≡ force`, but not the infinite path (you need a different</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">one that I couldn't come up with to pass the termination checker, at least).</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">Possibly sized types would let it still go through? I don't really know those</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">well enough to say.</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif"><br></div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">-- Dan<br></div></div></div></div></div><br><div class="gmail_quote"><div dir="ltr" class="gmail_attr">On Wed, Apr 10, 2019 at 7:16 PM Jon Sterling <<a href="mailto:jon@jonmsterling.com">jon@jonmsterling.com</a>> wrote:<br></div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">It is not too surprising to me that this example turned out to be degenerate, considering that we do not yet know exactly what higher coinductive types are ;-) and whether they have anything to do with quotients of coinductive types.... <br>
<br>
I'm optimistic that we can find ways to use (and constrain!) these tools which do not have such surprising results :)<br>
<br>
Best,<br>
Jon<br>
<br>
<br>
On Wed, Apr 10, 2019, at 7:05 PM, Dan Doel wrote:<br>
> Actually, perhaps it isn't fair to say that it's an oddity in this case,<br>
> because νμ is actually what we want for the lowest level, but not<br>
> what we want for the path level, and it would be more odd for the<br>
> fixed points to be swapped between levels.<br>
> <br>
> -- Dan<br>
> <br>
> On Wed, Apr 10, 2019 at 6:47 PM Dan Doel <<a href="mailto:dan.doel@gmail.com" target="_blank">dan.doel@gmail.com</a>> wrote:<br>
> > It seems like what's going on here is kind of related to the somewhat<br>
> > odd behavior of coinduction in Agda in general, where every set of<br>
> > definitions involving coinduction is always νμ. This means that there<br>
> > is a never _path_ that chains arbitrarily many `steps` together. But<br>
> > what you really want for things to work out is for the paths to be well<br>
> > founded, so that an `== now x` has to eventually reach the now.<br>
> > <br>
> > Is this fixed by first defining the coinductive Delay, and then inductively<br>
> > defining a HIT like:<br>
> > <br>
> >  data Part (A : Set) : Set where<br>
> >  include : Delay A -> Part A<br>
> >  step : ∀ d -> include (later d) == include (force d)<br>
> > <br>
> > since the steps no longer tie through a coinductive type?<br>
> > <br>
> > On Tue, Apr 9, 2019 at 4:09 AM Andrea Vezzosi <<a href="mailto:sanzhiyan@gmail.com" target="_blank">sanzhiyan@gmail.com</a>> wrote:<br>
> >> On Mon, Apr 8, 2019 at 8:38 PM Nicolai Kraus <<a href="mailto:nicolai.kraus@gmail.com" target="_blank">nicolai.kraus@gmail.com</a>> wrote:<br>
> >>  ><br>
> >>  > Great!! :)<br>
> >>  > That means we know what this type is: Delay(A) = 1.<br>
> >>  > It's not so clear (to me) though how we can justify these higher<br>
> >>  > coinductive types.<br>
> >> <br>
> >>  It seems that this example should make sense as a cubical set in the<br>
> >>  same style as the construction of HITs in CTT ?<br>
> >>  Just defined as a mixed inductive-coinductive type rather than purely inductive.<br>
> >> <br>
> >> <a href="https://arxiv.org/abs/1802.01170" rel="noreferrer" target="_blank">https://arxiv.org/abs/1802.01170</a><br>
> >> <br>
> >>  ><br>
> >>  > On 08/04/19 19:34, Andrea Vezzosi wrote:<br>
> >>  > > Oh, yeah, I hadn't thought about it, but indeed there's nothing<br>
> >>  > > special about "now" here.<br>
> >>  > ><br>
> >>  > > mutual<br>
> >>  > > never′≡ : ∀ (x : Delay′ A) → never′ ≡ x<br>
> >>  > > never′≡ x i .force = never≡ (x .force) i<br>
> >>  > ><br>
> >>  > > never≡ : ∀ (x : Delay A) → never ≡ x<br>
> >>  > > never≡ x i = step (never′≡ (delay x) i) i<br>
> >>  > ><br>
> >>  > ><br>
> >>  > ><br>
> >>  > > On Mon, Apr 8, 2019 at 8:11 PM Nicolai Kraus <<a href="mailto:nicolai.kraus@gmail.com" target="_blank">nicolai.kraus@gmail.com</a>> wrote:<br>
> >>  > >> Wow, thanks, Andrea!<br>
> >>  > >> Can this proof be extended to show that Delay(A) is contractible?<br>
> >>  > >> -- Nicolai<br>
> >>  > >><br>
> >>  > >> On 08/04/19 19:01, Andrea Vezzosi wrote:<br>
> >>  > >>> Here is a proof that "never" is equal to "now x", making use of path<br>
> >>  > >>> abstraction and copatterns.<br>
> >>  > >>><br>
> >>  > >>> mutual<br>
> >>  > >>> never′ : Delay′ A<br>
> >>  > >>> never′ .force = never<br>
> >>  > >>><br>
> >>  > >>> never : Delay A<br>
> >>  > >>> never = later never′<br>
> >>  > >>><br>
> >>  > >>> mutual<br>
> >>  > >>> never≡now′ : ∀ (x : A) → never′ ≡ delay (now x)<br>
> >>  > >>> never≡now′ x i .force = never≡now x i<br>
> >>  > >>><br>
> >>  > >>> never≡now : ∀ (x : A) → never ≡ now x<br>
> >>  > >>> never≡now x i = step (never≡now′ x i) i<br>
> >>  > >>><br>
> >>  > >>> Of course one still wonders what Delay really is.<br>
> >>  > >>><br>
> >>  > >>> This definition is accepted because the corecursion goes through the<br>
> >>  > >>> coinductive projection ".force" and both "step" and application to"i"<br>
> >>  > >>> are considered guardedness preserving.<br>
> >>  > >>><br>
> >>  > >>> On Tue, Apr 2, 2019 at 11:11 PM Nicolai Kraus <<a href="mailto:nicolai.kraus@gmail.com" target="_blank">nicolai.kraus@gmail.com</a>> wrote:<br>
> >>  > >>>> On 02/04/19 21:23, Jesper Cockx wrote:<br>
> >>  > >>>><br>
> >>  > >>>> Well, if `never` is equal to `now x`, then by transitivity `now x` is equal to `now y` for any `x` and `y`, which would mean I found a very complicated way to define the constant unit type :P<br>
> >>  > >>>><br>
> >>  > >>>><br>
> >>  > >>>> Right... the conjecture should be Delay(A) = Unit. I made a silly mistake before!<br>
> >>  > >>>> It's possible that the theory doesn't allow us to prove Delay(A) = 1, but I don't expect that we can show the negation of this.<br>
> >>  > >>>><br>
> >>  > >>>> About terminology: Nisse informed me that `Delay` is used for the (non-truncated) coinductive type with two constructors `now` and `later`, while the properly truncated variant where `later^n x` = `now x` for any finite `n` is called the partiality monad.<br>
> >>  > >>>><br>
> >>  > >>>><br>
> >>  > >>>> This is also the terminology that I know. In addition, probably one would want to call something "partiality monad" only if it actually is a monad. The definition for this that I find most elegant is the one by Tarmo and Niccolò (iirc, this definition ends up being equivalent to our suggestion in the "Partiality revisited" paper).<br>
> >>  > >>>><br>
> >>  > >>>> So my question is actually whether the partiality monad is definable as a higher coinductive type with two point constructors `now` and `later` plus some path constructor(s).<br>
> >>  > >>>><br>
> >>  > >>>> The problem with defining such a higher coinductive type `D` is that all attempts at proving two of its elements are *not* equal seem to fail:<br>
> >>  > >>>><br>
> >>  > >>>> - Pattern matching on an equality between two constructors with an absurd pattern () obviously doesn't work for higher inductive types.<br>
> >>  > >>>> - Defining a function `f : D -> Bool` or `D -> Set` which distinguishes the two elements doesn't work either because both `Bool` and `Set` are inductively defined, so `f` can only depend on a finite prefix of its input (i.e. f must be continuous).<br>
> >>  > >>>><br>
> >>  > >>>><br>
> >>  > >>>> `f : D -> Bool` shouldn't work even with a correct partiality monad, because it shouldn't be decidable whether an element is `never`. One could replace `Bool` by the Sierpinski space, which is by definition Partiality(1). (btw, `Set` is not inductively defined?)<br>
> >>  > >>>><br>
> >>  > >>>> - Defining an indexed datatype `data P : D -> Set` that is empty at one index but not at another seems to work, but then we get into trouble when we actually want to prove that it is empty for that particular index (this is not really surprising because indexed datatypes can be explained with normal datatypes + the equality type, so this is essentially the same as the first option).<br>
> >>  > >>>><br>
> >>  > >>>> This exhausts my bag of tricks when it comes to proving two constructor forms are not equal. This seems to be an essential problem that would pop up any time one tries to mix coinduction with higher constructors. It would be an interesting research topic to try and define a suitable notion of "higher coinductive type" which does not have this problem.<br>
> >>  > >>>><br>
> >>  > >>>><br>
> >>  > >>>> Right, but I think we current have no idea what cubical Agda's "higher coinductive types" are. It's interesting that Agda allows these, but they could as well be inconsistent. (That's why I asked about models before.)<br>
> >>  > >>>> -- Nicolai<br>
> >>  > >>>><br>
> >>  > >>>><br>
> >>  > >>>><br>
> >>  > >>>> -- Jesper<br>
> >>  > >>>><br>
> >>  > >>>> On Tue, Apr 2, 2019 at 10:06 PM Nicolai Kraus <<a href="mailto:nicolai.kraus@gmail.com" target="_blank">nicolai.kraus@gmail.com</a>> wrote:<br>
> >>  > >>>>> Interesting! So, in case Delay(Unit) does turn out to be contractible, we might also expect that Delay(A) = A. This doesn't seem intuitive to me, but it could still be true. Do you see a way to construct Delay(A) -> A? If there is such a function, it should be quite canonical, and maybe it's easier to write this function than to prove the contractibility. But if we can't do this, and we also can't distinguish 'now' and 'never', then I have no idea what Delay(A) actually is. Does any of the cubical models capture such constructions?<br>
> >>  > >>>>> (Maybe, at this point, we shouldn't call it "Delay" :)<br>
> >>  > >>>>> -- Nicolai<br>
> >>  > >>>>><br>
> >>  > >>>>><br>
> >>  > >>>>> On 02/04/19 15:08, Jesper Cockx wrote:<br>
> >>  > >>>>><br>
> >>  > >>>>> Hi Nicolai,<br>
> >>  > >>>>><br>
> >>  > >>>>> Yes, Christian and I suspected the same thing (that this definition of the delay monad is actually a unit type), but I haven't managed to prove that either because of some mysterious termination checker problem.<br>
> >>  > >>>>><br>
> >>  > >>>>> I'm currently trying a different approach where I define the Delay type mutually with the ⇓ type so I can quotient by the relation "normalize to the same value in a finite number of steps". I'll let you know later if it works.<br>
> >>  > >>>>><br>
> >>  > >>>>> -- Jesper<br>
> >>  > >>>>><br>
> >>  > >>>>> On Tue, Apr 2, 2019 at 3:15 PM Nicolai Kraus <<a href="mailto:nicolai.kraus@gmail.com" target="_blank">nicolai.kraus@gmail.com</a>> wrote:<br>
> >>  > >>>>>> Hi Jesper,<br>
> >>  > >>>>>><br>
> >>  > >>>>>> I find this construction very interesting since it's the first "cubical higher co-inductive type" that I've seen! Unfortunately, I don't know how these "CHCIT's" behave in Agda.<br>
> >>  > >>>>>><br>
> >>  > >>>>>> If I had to guess, I would expect that you *cannot* distinguish now and never, which would mean that your construction doesn't give you what you wanted. The difference to the quotiented delay monad (or, for what it's worth, the QIT/QIIT partiality monad) is that your construction inserts the equations "coinductively" (usually, only the later-steps are coinductive).<br>
> >>  > >>>>>><br>
> >>  > >>>>>> Thus, my guess is that Delay(Unit) could be contractible. One could try to prove that every element is equal to 'now'.<br>
> >>  > >>>>>><br>
> >>  > >>>>>> Cheers,<br>
> >>  > >>>>>> Nicolai<br>
> >>  > >>>>>><br>
> >>  > >>>>>><br>
> >>  > >>>>>> On 29/03/19 18:40, Jesper Cockx wrote:<br>
> >>  > >>>>>><br>
> >>  > >>>>>> Hi all,<br>
> >>  > >>>>>><br>
> >>  > >>>>>> As an experiment with cubical agda, I was trying to define a quotiented version of the Delay monad as a higher inductive type. I'm using this definition:<br>
> >>  > >>>>>><br>
> >>  > >>>>>> data Delay (A : Set ℓ) : Set ℓ<br>
> >>  > >>>>>><br>
> >>  > >>>>>> record Delay′ (A : Set ℓ) : Set ℓ where<br>
> >>  > >>>>>> coinductive<br>
> >>  > >>>>>> field<br>
> >>  > >>>>>> force : Delay A<br>
> >>  > >>>>>><br>
> >>  > >>>>>> open Delay′ public<br>
> >>  > >>>>>><br>
> >>  > >>>>>> data Delay A where<br>
> >>  > >>>>>> now : A → Delay A<br>
> >>  > >>>>>> later : Delay′ A → Delay A<br>
> >>  > >>>>>> step : (x : Delay′ A) → later x ≡ x .force<br>
> >>  > >>>>>><br>
> >>  > >>>>>> I managed to implement some basic functions on it but I got stuck on trying to prove the looping computation 'never' does not in fact evaluate to any value. My code is available here: <a href="https://github.com/jespercockx/cubical/commit/f1647a90c1b27aadd5da748f08e23630221cc3d9" rel="noreferrer" target="_blank">https://github.com/jespercockx/cubical/commit/f1647a90c1b27aadd5da748f08e23630221cc3d9</a> I looked at the problem together with Christian Sattler and we are not even sure it is actually provable. Does anyone have an idea how to proceed? Or has someone already experimented with coinductive types in cubical and encountered similar problems? (I looked at the paper "Partiality revisited" by Thorsten, Nisse and Nicolai but they use a very different definition of the partiality monad.)<br>
> >>  > >>>>>><br>
> >>  > >>>>>> Cheers,<br>
> >>  > >>>>>> Jesper<br>
> >>  > >>>>>><br>
> >>  > >>>>>><br>
> >>  > >>>>>> _______________________________________________<br>
> >>  > >>>>>> Agda mailing list<br>
> >>  > >>>>>> <a href="mailto:Agda@lists.chalmers.se" target="_blank">Agda@lists.chalmers.se</a><br>
> >>  > >>>>>> <a href="https://lists.chalmers.se/mailman/listinfo/agda" rel="noreferrer" target="_blank">https://lists.chalmers.se/mailman/listinfo/agda</a><br>
> >>  > >>>>>><br>
> >>  > >>>>>><br>
> >>  > >>>>>> _______________________________________________<br>
> >>  > >>>>>> Agda mailing list<br>
> >>  > >>>>>> <a href="mailto:Agda@lists.chalmers.se" target="_blank">Agda@lists.chalmers.se</a><br>
> >>  > >>>>>> <a href="https://lists.chalmers.se/mailman/listinfo/agda" rel="noreferrer" target="_blank">https://lists.chalmers.se/mailman/listinfo/agda</a><br>
> >>  > >>>> _______________________________________________<br>
> >>  > >>>> Agda mailing list<br>
> >>  > >>>> <a href="mailto:Agda@lists.chalmers.se" target="_blank">Agda@lists.chalmers.se</a><br>
> >>  > >>>> <a href="https://lists.chalmers.se/mailman/listinfo/agda" rel="noreferrer" target="_blank">https://lists.chalmers.se/mailman/listinfo/agda</a><br>
> >>  ><br>
> >>  _______________________________________________<br>
> >>  Agda mailing list<br>
> >> <a href="mailto:Agda@lists.chalmers.se" target="_blank">Agda@lists.chalmers.se</a><br>
> >> <a href="https://lists.chalmers.se/mailman/listinfo/agda" rel="noreferrer" target="_blank">https://lists.chalmers.se/mailman/listinfo/agda</a><br>
> _______________________________________________<br>
> Agda mailing list<br>
> <a href="mailto:Agda@lists.chalmers.se" target="_blank">Agda@lists.chalmers.se</a><br>
> <a href="https://lists.chalmers.se/mailman/listinfo/agda" rel="noreferrer" target="_blank">https://lists.chalmers.se/mailman/listinfo/agda</a><br>
><br>
_______________________________________________<br>
Agda mailing list<br>
<a href="mailto:Agda@lists.chalmers.se" target="_blank">Agda@lists.chalmers.se</a><br>
<a href="https://lists.chalmers.se/mailman/listinfo/agda" rel="noreferrer" target="_blank">https://lists.chalmers.se/mailman/listinfo/agda</a><br>
</blockquote></div>