r/dependent_types • • Nov 21 '21

Help the Proof Assistants Stack Exchange reach Beta!

Thumbnail
area51.stackexchange.com
52 Upvotes

r/dependent_types • • Feb 25 '23

How to implement dependent types in 80 lines of code

Thumbnail
gist.github.com
48 Upvotes

r/dependent_types • • May 29 '21

ATS: Why Linear Types are the Future of Systems Programming

Thumbnail
youtube.com
42 Upvotes

r/dependent_types • • Jun 20 '13

Homotopy Type Theory: Univalent Foundations of Mathematics

Thumbnail
homotopytypetheory.org
40 Upvotes

r/dependent_types • • Aug 09 '19

Arend – a proof assistant by JetBrains based on cubical type theory

Thumbnail arend-lang.github.io
37 Upvotes

r/dependent_types • • Jan 23 '18

Cubical Adventures - Conor McBride

Thumbnail
youtube.com
37 Upvotes

r/dependent_types • • Jun 09 '22

Functional Programming in Lean - an in-progress book on using Lean 4 as a programming language

Thumbnail leanprover.github.io
35 Upvotes

r/dependent_types • • Dec 30 '19

"The future of mathematics?" by Kevin Buzzard, featuring Lean theorem prover (talk + slides)

Thumbnail
youtube.com
34 Upvotes

r/dependent_types • • Feb 06 '18

Martin Hofmann found dead on Japanese mountain

Thumbnail groups.google.com
34 Upvotes

r/dependent_types • • Mar 07 '19

What can refinement types do that dependent types can't?

33 Upvotes

I started looking at the F* tutorial last night after fooling around for a month with Idris and I'm having trouble understanding how refinement types aren't just a special use-case for dependent types.

Suppose I have some function f with argument x of type a meeting some precondition phi and the output is of type b and meets some postcondition psi.

Then in F* the type signature would be

val f: x:a{phi(x)} -> b{psi(f c)}

But in Idris couldn't I always replicate this functionality by defining appropriate types Phi x and Psi (f x) and a function with the type signature:

f : (x : a)  ** Phi x -> (f x) ** Psi (f x)

With dependent types and sigma types do we get everything refinement types have to offer? Sorry if this is a dumb question, I'm still new to this type theory game.


r/dependent_types • • Jan 05 '15

Conor McBride started blogging!

Thumbnail
pigworker.wordpress.com
33 Upvotes

r/dependent_types • • Nov 14 '20

Cost-Aware Type Theory

Thumbnail arxiv.org
31 Upvotes

r/dependent_types • • Jan 26 '18

Martin Hofmann reported missing; last seen in Nikko City on 20 January

Thumbnail shonan.nii.ac.jp
31 Upvotes

r/dependent_types • • Apr 02 '15

Warming up to Homotopy Type Theory

Thumbnail
pigworker.wordpress.com
31 Upvotes

r/dependent_types • • Feb 04 '14

New release of Idris: 0.9.11

Thumbnail idris-lang.org
31 Upvotes

r/dependent_types • • Jul 07 '21

Mathematicians welcome computer-assisted proof in ‘grand unification’ theory

Thumbnail
nature.com
30 Upvotes

r/dependent_types • • Feb 05 '19

William J. Bowman, Ph.D. - Compiling with Dependent Types.

Thumbnail
williamjbowman.com
30 Upvotes

r/dependent_types • • Jun 20 '13

Coq: The world's best macro assembler? (PDF)

Thumbnail personal.cis.strath.ac.uk
30 Upvotes

r/dependent_types • • Dec 23 '21

Rust-like memory management with dependent types

29 Upvotes

I am interested in the design space at the intersection of region-based memory management, as present in Rust, and dependent types. In Rust lifetimes are another thing types can be parametrized by, which seems like it would translate well into a separate Sort in type theory.

I am wondering whether the additional expressiveness of dependent types would make it possible to introduce a simpler, more fundamental concept, from which references guarded by lifetimes could be derived. It would seem that the fundamental issue is that a value can become no longer usable after some other action is taken by the program, which invalidates the borrow. Is this property present in other corners of the world of type systems?

I am aware of, but not terribly familiar with ATS. It seems to me that the way they solve these issues is to require that the borrowing value is explicitly destroyed, which recovers the fractional permissions that then let you invalidate the borrow. I would like to find an approach that's not as explicit.


r/dependent_types • • Oct 06 '18

Cedille Cast #1: Deriving Induction (Pt. 1)

Thumbnail
youtube.com
29 Upvotes

r/dependent_types • • Dec 02 '16

Type Theory Podcast Episode 6: Aaron Stump on Cedille

Thumbnail
typetheorypodcast.com
29 Upvotes

r/dependent_types • • Nov 08 '17

What's the latest news about cubical type theory (and in general univalent type theory)?

28 Upvotes

Coming from a math background, I've been following univalent math related stuff on and off. I wonder what the latest development in cubical type theory is.

After some search I've been looking at the cubical type theory paper, experimenting with cubicaltt, and skimming through the canonicity for cubical type theory paper. So questions for the experts and informed, do we believe cubical type theory is "the" univalent type theory or are there competitors (if so what are the merits of different approach)? Is normalization and decidability of type checking of cubical type theory close to being proved or essential difficulties are found?

(Any relevant comments are welcome. Do not just restrict your comments to questions above which only came from my limited knowledge of the field.)


r/dependent_types • • May 02 '21

Learn coq or agda before diving into idris2?

27 Upvotes

Hey. A week ago I quit my job because, as a self-taught programmer with no academic background, I wanted the some time to dive into some CS and math. I don't have forever though so I'm trying to work as efficiently as possible.

One of my goals for this period is to become comfortable with a proof assistant. My reason for this is because my lack of mathemathical background and because my other goals are a bit more focused on theory (I want to become fairly familiar with PL, HoTT and Category Theory) and I think that having a proof assistant by my side will be very helpful in achieving those goals.

I considered Coq, Agda and Idris, and I ended up choosing Idris because of the fact that it is a more general purpose programming language and I would like to use it for some more software engineering purposes as well.

Before I get started with Idris though, I thought it would be a good idea to start with some fundamental theory. I found both software foundations in coq (I've been following this for the past week and I have been loving it so far) and software foundations in agda.

My questions are:

  • Do you think that a proof assistant is actually going to be useful in learning fields like HoTT, Category Theory and PL?

  • Do you think Idris will be useful for learning fields like HoTT, Category Theory and PL? (Since Idris focuses on general purposes programming, I worry that perhaps the proof assistant is significantly less productive to work with than for instance Coq or Agda.)

  • (for the peole who know one of these books): Which book did you follow? Did you like it? How relevant are its contents to Idris?

  • (for the people who know both of these books): Did you have a personal preference? Which one do you think will be more useful as a primer for Idris stuff.

  • In general, is Coq or Agda more similar to Idris?

I'm sorry for the amount of questions. I hope some of you will take the time to answer some of them. It would help me a lot :)


r/dependent_types • • Apr 16 '21

Beyond inductive datatypes: exploring Self types

Thumbnail
github.com
27 Upvotes

r/dependent_types • • Aug 31 '20

A Gentle Introduction to Dependent Types

27 Upvotes

Dear Dependent Types redditors,

Our team Metastate has been working on an open-source project called Juvix, which leverages dependent types. In order to spread the concept of dependent types a bit further among the worldwide community of programmers (functional or general) that might be interested, we've written this article "A gentle introduction to dependent types". Although the members of this subreddit might already be familiar with the concept, feedback on the article is always welcome.