Quantum Programming EDSLs other than Quipper

Hi all, Quipper [1] is a well-known library that provides an EDSL for writing and simulating quantum algorithms in Haskell. I was wondering if there was any other attempt to design an EDSL in Haskell to express quantum algorithms. In particular, Quipper is not able to statically ensure that the algorithm written is physically meaningful, as one could violate the "non-cloning property", for example (a qubit cannot be copied, for those who do not speak quantumly). Violations like this are detected at runtime when simulating the algorithm or when producing the corresponding circuit as output. Authors of Quipper already said that some of those properties could be possible to check “if Haskell had linear types”. The point is that Haskell's support for dependently typed programming has grown quite a lot in the last years, and I think that, at least theoretically, something better can now be achieved. So do anyone know any more recent attempt to express quantum computations in an Haskell EDSL that leverages cutting-edge type-level features to statically check for physically meaningful programs? Greetings, Nicola [1]: http://www.mathstat.dal.ca/~selinger/quipper/

Hello !
So my colleagues and I have some linear logical language engineering in
various states of immaturity at github.com/hopper-lang
Last fall Jeff polakow presented a paper at Haskell symposium or Icfp
(forget which) for embedding linear types in Haskell , might be worth
googling around for a copy of that paper (Google scholar might get you a
non paywalled pdf)
There's some cool stuff related to this I hope to share with the community
in the near future, but that's all I can offer off the cuff
On Saturday, May 28, 2016, Nicola Gigante
Hi all,
Quipper [1] is a well-known library that provides an EDSL for writing and simulating quantum algorithms in Haskell.
I was wondering if there was any other attempt to design an EDSL in Haskell to express quantum algorithms.
In particular, Quipper is not able to statically ensure that the algorithm written is physically meaningful, as one could violate the "non-cloning property", for example (a qubit cannot be copied, for those who do not speak quantumly). Violations like this are detected at runtime when simulating the algorithm or when producing the corresponding circuit as output.
Authors of Quipper already said that some of those properties could be possible to check “if Haskell had linear types”. The point is that Haskell's support for dependently typed programming has grown quite a lot in the last years, and I think that, at least theoretically, something better can now be achieved.
So do anyone know any more recent attempt to express quantum computations in an Haskell EDSL that leverages cutting-edge type-level features to statically check for physically meaningful programs?
Greetings, Nicola
[1]: http://www.mathstat.dal.ca/~selinger/quipper/ _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org javascript:; http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe

Il giorno 28 mag 2016, alle ore 19:53, Carter Schonwald
Hello ! So my colleagues and I have some linear logical language engineering in various states of immaturity at github.com/hopper-lang
Nice! I will take a look!
Last fall Jeff polakow presented a paper at Haskell symposium or Icfp (forget which) for embedding linear types in Haskell , might be worth googling around for a copy of that paper (Google scholar might get you a non paywalled pdf)
Yes, I saw his paper and it was indeed what made me think about what Quipper authors said.
There's some cool stuff related to this I hope to share with the community in the near future, but that's all I can offer off the cuff
Then I hope the near future comes soon enough ;) Greetings, Nicola

https://github.com/NICTA/cogent/ is also a (very different!) linear logical
language thats recently been made public by nicta, the associated papers on
their projects are very illuminating. and either way, thers a lot of great
theoretical and semi applied work intersecting with linear logical
semantics thats ripe for use :)
On Sat, May 28, 2016 at 11:39 AM, Nicola Gigante
Il giorno 28 mag 2016, alle ore 19:53, Carter Schonwald < carter.schonwald@gmail.com> ha scritto:
Hello ! So my colleagues and I have some linear logical language engineering in various states of immaturity at github.com/hopper-lang
Nice! I will take a look!
Last fall Jeff polakow presented a paper at Haskell symposium or Icfp (forget which) for embedding linear types in Haskell , might be worth googling around for a copy of that paper (Google scholar might get you a non paywalled pdf)
Yes, I saw his paper and it was indeed what made me think about what Quipper authors said.
There's some cool stuff related to this I hope to share with the community in the near future, but that's all I can offer off the cuff
Then I hope the near future comes soon enough ;)
Greetings, Nicola

Il giorno 28 mag 2016, alle ore 21:25, Carter Schonwald
ha scritto: https://github.com/NICTA/cogent/ https://github.com/NICTA/cogent/ is also a (very different!) linear logical language thats recently been made public by nicta, the associated papers on their projects are very illuminating. and either way, thers a lot of great theoretical and semi applied work intersecting with linear logical semantics thats ripe for use :)
I’m sure a lot of work has been done on this front! I’m wondering how far all these things can be embedded in Haskell. Current dependent types extensions should allow to express linear types but I’m curious about how a specific extension to the type system would look. Who knows! Nicola
participants (2)
-
Carter Schonwald
-
Nicola Gigante