Homotopy Type Theory

Mathematics is having a replication crisis and people pay so little attention they don’t know. That replication crisis has led to efforts in formal verification such as HoTT, Lean, etc. https://homotopytypetheory.org/ https://xenaproject.wordpress.com/2021/06/05/half-a-year-of-the-liquid…

Much of theoretical computer science uses categorical methods, for example, as semantics for type theory. In that field, such techniques are often more natural than set-theoretic ones due to issues of computability, decidability, etc. So at the very least, much of that research as originally written would be inaccessible to a non category theorist. Whether that field counts as mathematics and if it does whether it is worth missing out on depends on taste of course, but an example would be 'homotopy type theory' https://homotopytypetheory.org

> The overlap of mathematicians who care about category theory [...] and mathematicians who program [...] is pretty much zero. You probably won't find your algebraic topology professor programming Well, unless perhaps s/he has some involvement in a project like this one http://comptop.stanford.edu/ ("The overall goal of this project is to develop flexible topological methods which will allow the analysis of data which is difficult to analyze using classical linear methods"; first named person in left sidebar is an algebraic topologist). Or this one http://www.esf.org/index.php?id=8764 ("Applied and Computational Algebraic Topology"; first named person on steering committee is an algebraic topologist). Or this one http://munkres.us.es:8080/groups/catam/ ("Computational Applied Topology and Applied Mathematics"; directory is an algebraic topologist). Or, turning away from algebraic topology as such to mathematics inspired by algebraic topology and involving both category theory and programming: http://homotopytypetheory.org/ ("... new program for a comprehensive, computational foundation for mathematics based on the homotopical interpretation of type theory. [...] currently being implemented with the help of the automated proof assistant Coq"; note that in practice doing nontrivial things in Coq is a matter of functional programming). For sure there are plenty of mathematicians (in algebraic topology and elsewhere) who don't program, but I think the intersection between…

This is a very good thought. Some current projects are trying to develop computable mathematical foundations in a more structured way. Homotopy type theory (http://homotopytypetheory.org/) is one example that has a lot of buzz around it just now, but automated theorem proving has been trying to work with higher-order concepts for ages now. In the classical approach of "compiling" everything into sets/logic/etc., you end up with just the assembly language problem that's being discussed, where all the high-level structure vanishes. In order to do your bottom-up approach instead, one of the things that needs to happen is to make the theory really compositional, so that once you've defined some abstraction or higher-level concept, you can use it in constructions and proofs without having to break the abstraction. You don't need to know - and in fact you shouldn't be able to find out - just how the natural numbers were constructed, as long as they work by the right rules. This motivates the use of type theory to describe mathematical objects, and say which operations are allowed. We want to be able to add two numbers and get another number, but we don't want to be able to intersect two numbers as if they were sets, even if they happen to have been built out of sets. So I think you are right - or at least, there are plenty of people who agree with you that this is a good idea. It is difficult to actually do, of course, but that's life.

The author is correct that checking if two functions having infinite domains are equal is often impossible. He also has correct statements of some mathematical theorems. But people in this thread have provided counterexamples to his claim. That means he needs to fix the mistakes he made. If you are interested in what serious mathematicians have to say on this topic see https://homotopytypetheory.org/.

Isn't Vladimir Voevodsky's [1] Univalent Foundations [2] / Homotopy Type Theory [3] a new candidate challenging to subsume set theory as the foundations of mathematics [4]? [1] https://en.wikipedia.org/wiki/Vladimir_Voevodsky [2] https://en.wikipedia.org/wiki/Univalent_foundations [3] https://homotopytypetheory.org/ [4] https://www.youtube.com/results?search_query=Vladimir+Voevodsky+unival…

Concerning the books on the topic, I highly recommend this: https://www.amazon.com/Verified-Functional-Programming-Agda-Books/dp/1… If you want to get into the math related aspect, read this: https://homotopytypetheory.org/book/ There's also an annual summer school on the topic which has downloadable videos available: https://www.cs.uoregon.edu/research/summerschool/summer17/

Homotopy Type Theory by Vladimir Voevodsky is another possibility. This is an attempt to link Topology and Computer Science https://homotopytypetheory.org/book/ Back in the day there was Feynman's Lectures on Computation. Hint: pdf can be found by searching https://www.amazon.com/Feynman-Lectures-Computation-Richard-P/dp/07382… See also nLab https://ncatlab.org/nlab/show/higher+category+theory one should never forget Jacob Lurie's "Higher Topos Theory" which is 1000 pages just like that http://www.math.harvard.edu/~lurie/papers/croppedtopoi.pdf Actually I recommend against readin it as it only covers 2 of the 4 topics you discuss (Topology and Logic). However it certainly has applications to the other two.

> A mathematical formalism that could be interpreted in a purely mechanical way would be a huge improvement. Look at Homotopy Type Theory: > https://homotopytypetheory.org/

This is the same Voevodsky that came up with the univalence axiom[1] that is foundational in HoTT[2] (homotopy type theory)? What's not to love about: The univalence axiom states: (A = B) ≃ (A ≃ B) "In other words, identity is equivalent to equivalence. In particular, one may say that 'equivalent types are identical'." [1] https://en.wikipedia.org/wiki/Homotopy_type_theory#Univalence_axiom [2] http://homotopytypetheory.org/book/

In the grand scheme of things all the errors he mentioned do not make a difference to the overall direction of the proof. Syntactic errors in programs on the other hand do. Unused variables, equality instead of assignment, declared but uninitialized variables, etc. are almost always bugs. That's not the case with math. That's not to say this line of reasoning is not worthwhile. PLT Redex already does something similar for programming language semantics: http://redex.racket-lang.org/. Catching bugs in programming language semantics works for the same reason catching bugs in C works. There is a formal grammar with well-defined meaning that doesn't exist in general mathematical discourse. There is work being done in that direction as well: http://homotopytypetheory.org/book/. I wouldn't call that linting though.

What's wrong to think that types are important? From mathematical point of view, types are interpreted as theorem statements and functions(values) that typecheck are considered proofs of those theorems. Types are fundamental. See Curry-Howard correspondence http://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspondence or, if feeling adventurous, Homotopy type theory dubbed to be a new foundation of mathematics: http://en.wikipedia.org/wiki/Homotopy_type_theory and http://homotopytypetheory.org/

> Prop vs Decidable - I vaguely understand the distinction, but can use more examples. Also would like to know does this relate to the noncomputable property. My path to this subject was tortured, so sorry if I don’t account for Polysemy etc. With Prop, I think what you need to dig into is ‘non-computational’ not ‘non-computable’. Mere propositions is probably best viewed with Homotopy Type Theory[0] Two proofs (t1,t2) of the same proposition (p:Prop) which are definitionally equal are proof irrelevant, meaning that all they carry is the proof p is true. This paper [1] may be helpful but the difference between groupoids and subsingletons with classical mathematics is challenging for many of us. Hopefully this helps in your journey. Also remember that with classical set theory the internal and external proposition truths are different, the Curry–Howard correspondence is to constructivist from lambda calculus, you don’t have PEM etc… Remember DGM[2] shows that finite indexing or projection is PEM Good luck and I hope you continue to share your journey. [0] https://homotopytypetheory.org/wp-content/uploads/2013/03/hott-online-… [1] https://jesper.sikanda.be/files/definitional-proof-irrelevance-without… [2] https://ncatlab.org/nlab/show/Diaconescu-Goodman-Myhill+theorem

Wait what? Computer science encompasses mathematics. Any proof that can be validated by following a known set of reduction steps until axiomatic statements are reached (i.e. any proof worth the paper it’s written on) can be verified just as well by a computer as a person. For your specific case: definition infinite_primes (n : nat) : {p | p ≥ n ∧ prime p} := let m := fact (n + 1) in have m ≥ 1, from le_of_lt_succ (succ_lt_succ (fact_pos _)), have m + 1 ≥ 2, from succ_le_succ this, obtain p `prime p` `p ∣ m + 1`, from sub_prime_and_dvd this, have p ≥ 2, from ge_two_of_prime `prime p`, have p > 0, from lt_of_succ_lt (lt_of_succ_le `p ≥ 2`), have p ≥ n, from by_contradiction (suppose ¬ p ≥ n, have p < n, from lt_of_not_ge this, have p ≤ n + 1, from le_of_lt (lt.step this), have p ∣ m, from dvd_fact `p > 0` this, have p ∣ 1, from dvd_of_dvd_add_right (!add.comm ▸ `p ∣ m + 1`) this, have p ≤ 1, from le_of_dvd zero_lt_one this, absurd (le.trans `2 ≤ p` `p ≤ 1`) dec_trivial), subtype.tag p (and.intro this `prime p`) https://homotopytypetheory.org/2015/12/02/the-proof-assistant-lean/

Proof assistants such as Lean are inching their way into the mainstream. Ideas from topos theory, higher category theory, and homotopy theory are all running together: https://homotopytypetheory.org/book/ I'd argue that any new programming language should be designed with an awareness of the languages of formal proof. Otherwise one is barking up the wrong tree. Samuel Eilenberg, perhaps the most influential mathematician to pass through Columbia's math department doors, was in his later years a pioneer of topos theory. Colleagues viewed this with respect and puzzlement; no one else had much of a clue what topos theory even was. As a kid, I saw a photo of Eilenberg "working", deep in afternoon thought while reclining in his apartment, in a Time/Life book on mathematics. I thought, "What a great job!" Years later, he called to hire me. Early on the job, I was out drinking with friends after midnight, way downtown, when a fellow postdoc spotted Sammy at the bar. "What if he sees us!?" Huh, he's here too. We moved across the street to a quieter bar, then I saw him looking for a cab, and invited him to join the four of us. We were out together past dawn, and he beat me into the department that day, as chair. He was seventy.

The introduction and chapter 1 of the (free) homotopy type theory book (http://homotopytypetheory.org/book/) provide a great overview of type theory and the Curry-Howard correspondence which, for me, was the moment when I developed a deep appreciation for (non-broken) type systems. Many of us are probably only exposed to type systems through, say, Java. This is unfortunate because Java's type system is rather primitive, and limits one's ability to take full advantage of Curry-Howard. Scala provides a good environment for developing some introductory experience with type-level programming, since it is sort of halfway* between Java and a dependently-typed programming language like Idris. *=Scala has higher-kinded types, path-dependent types (weaker than dependent types, but allows you to see what all the fuss is about), existential types, and implicit arguments - many of the ingredients that you will find in many theorem provers and proof assistants which, interestingly, rely on type theory (via Curry-Howard). Java has none of those.

j2kun's characterisation of HoTT is misleading. Their goal is also to rewrite all of mathematics in a constructive way, This is not the goal of HoTT, and also not possible as some mathematics is intrinsically non-constructive. HoTT allows non-constructive reasoning, see section 3.4 "Classical vs. intuitionistic logic" of the HoTT book http://homotopytypetheory.org/book/. You can say that HoTT derives non-constructive mathematics on top of constructive foundations. The HTTs are also claiming that proofs in their framework can be logically checked by a computer (because it is constructive) No. Whether a proof can be logically checked by a computer has nothing to do with whether it is constructive or not. A proof is just a syntactic object. It's just as easy to check if a proof step uses excluded middle or double negation as it is to check whether it uses a construtive principle like /\-introduction. There are many proof assitants that work with classical logic, e.g. Mizar, HOL, HOL light, Isabelle/HOL ... All of SAT-solving works classically. The novelty of HoTT, and only extension over intensional Martin-Loef type-theory, is the univalence axiom.

>>So I wonder what he thinks of this new univalent foundation. The Homotopy Type Theory (HoTT) book[1] puts forth a possible interpretation of Conway's thoughts about univalent foundations in section 11.6 (look at the bottom of the page for the following very selective and paraphrased quote): "[...] Conway's point was not to complain about ZF in particular, but to argue against all foundational theories at once [...] One might respond that, in fact, univalent foundations is not one of the "standard foundational theories" which Conway had in mind, but rather the metatheory in which we may express our ability to create new theories, and about which we may prove Conway's metatheorem."[2] [1] http://homotopytypetheory.org/book/ [2] http://www.math.ntnu.no/~stacey/documents/HoTT-online/main126.xhtml EDIT: I forgot to mention that Voevodsky's definition of "Univalent Foundations" seems to be used interchangeably with the term "Homotopy Type Theory", but in Voevodsky's mind there is a sharp distinction[3]. Voevodsky tried to make this clear in an HoTT Google Groups email thread with the following statement: "HoTT is the study of the type-theoretic approach to the meta-theory of the Univalent Foundations."[4] [3] http://en.wikipedia.org/wiki/Homotopy_type_theory#Univalent_foundation… [4] https://groups.google.com/forum/#!topic/homotopytypetheory/zEixM1M3ZDQ…

Since fidotron has been piled on, let me defend the point in his/her post. Good mathematics has come out of being worried that what other mathematicians have done isn't quite right, and I think the perspective of the article doesn't acknowledge that. For example: Cantor's theorem is quite true, only cranks doubt it [1]. But many mathematicians take it to have the corollary that cardinalities greater than that of the natural numbers exist, which does not follow: it is perfectly coherent to say that constructions such as the power set of natural numbers do not exist as a definite whole, and so do not have a cardinality. These kinds of doubt have driven constructivism which has led to interesting work in topology, measure theory, and type theory, and led to such useful applications as calculators for exact real arithmetic. Cantor's paradise seems to be coherent (likewise I would be deeply surprised if large parts of mathematics turned out to be misconstrued) but the assumptions of large cardinal set theory are grandiose and poorly justified, and yet for a long time those people who wondered if it was wise to embrace the whole edifice were marginalised. It seems that now there are many more mathematicians who are interested in revisiting this perspective [2]. To put Wiles' metaphor in perspective, it is good if some mathematicians step outside the mansion from time to time, to see if the superstructure is up to all the crashing about that happens in the dark rooms. [1]:…

This is fascinating to me. A couple comments and links. Here is a course on proof theory that uses Coq [1]. It is actually the course that Vladimir Voevodsky took when he was trying to understand proof and type theory [2], [3]. While writing the midterm paper, he discovered homotopy type theory [4]. More details on the bitcoin scripting language can be found in the excellent blog post by Michael Nielsen[5]. If the escrow model is implemented, you can actually imagine the mathematical proof market maker acting like a bank, loaning out or otherwise investing bitcoins while the world waits for a verified proof; say, of the abc conjecture [6a] or the goldbach conjecture [6b]. This might be one small way to disrupt Wall St [7a], [7b]. In particular, such a market, when more highly developed, provides skilled mathematicians and scientists incentives to work on math and ( computer ) science problems in an open source format that benefits everyone - since everyone can look at and learn from their proofs - rather than quantitative trading in a closed format that actually causes long term social harm and political instability [IMHO]. I am thinking here of Goldman Sachs and Renaissance Technology founded by James Simons. Imagine if an incentive structure existed that encouraged all these smart folks to work on what is essentially verifiable open source software [8]. [1] http://www.cs.princeton.edu/courses/archive/fall09/cos441/index.php [2]…

> Design of Everyday Things, which I have to assume is at the high end of the unread-after-buying ratio. I don't believe that. I'd say the high-end begins with Knuth's TAOCP with the end of the spectrum being something like HOTT https://homotopytypetheory.org/book/

For dependent types, I would look at Idris [1]. Adding Univalence in a satisfying way is I think still somewhat of a research question (I could be wrong, and if anyone has any additional insight would be interested to hear), i.e. see this thread about Univalence in Coq [2]. There are some implementations in Cubical Type Theory, but I am not sure what the state of the art is there [3] [1]https://www.idris-lang.org [2]https://homotopytypetheory.org/2012/01/22/univalence-versus-extraction… [3]https://redprl.org

I am a cluebie in this field, but I guess working your way through some Lean tutorials [1], and/or reading the introduction to the HoTT book [1] might either scare you off, or get you enthused enough to continue. [1] https://leanprover.github.io/theorem_proving_in_lean4/ [2] https://homotopytypetheory.org/book/

[0] https://en.wikipedia.org/wiki/Homotopy_type_theory [1] https://homotopytypetheory.org/book/

Is this [1] perhaps the book you’ll work through? [1] https://homotopytypetheory.org/book/

It's popular at CMU? It got a huge-for-pure-math grant 5 years ago (https://homotopytypetheory.org/2014/04/29/hott-awarded-a-muri/)? Idk.

Not sure what you mean by self-contained, but there is the Homotopy Type Theory book: https://homotopytypetheory.org/book/

This is a list of type theory resources: https://github.com/jozefg/learn-tt This is an exposition of Martin-Lof's dependent type theory: http://www.cs.nott.ac.uk/~psztxa/mgs-17/notes-mgs17.pdf Section 5 is about Homotopy Type Theory (HoTT), a newer type theory that is still being developed. Chapter 1 of the HoTT book introduces Martin-Lof's dependent type theory, then the rest of the book covers HoTT-specific topics: https://homotopytypetheory.org/book/

Abbreviation for Homotopy Type: https://homotopytypetheory.org/book/