387 Followers
628 Following
206 Posts
PhD student in PL (looking for postdoc for after
September)
Websitehttps://julesjacobs.com

The program for the Oregon Programming Languages Summer School 2026 looks exciting: https://www.cs.uoregon.edu/research/summerschool/summer26/

Come or send your students!

OPLSS 2026 | University of Oregon

a conference for graduate students and software industry professionals in advanced programming language techniques concentrating on safe and reliable parallel and concurent applications

@pervognsen $499 for students and employers of educational institutions!
@tao Coq lets you use the rewrite command for inequalities as well. I believe there is ongoing work to add this capability to Lean.
@tao A possibly somewhat analogous situation to the problem mentioned at the end of the discussion occurs in Iris (https://iris-project.org/). The approach they took was to avoid picking a concrete parameter space like ℝ × ℝ with coordinates x and y, and instead always work with statements that start with "for all parameter spaces that have an x and y".
Iris Project

@tao an interesting aspect of type theory is that proofs and terms are the same kind of thing. This means that you can also leave holes in terms, which can be very convenient as well.
@dysfun @tao Consider a lemma $f (2*n) = 0$. If we have a simp lemma $2*n = n+n$ then if we simp on the term $f (2*k)$, it may first change it to $f (k+k)$ and then the $f$ lemma won't apply any more. If we make sure that subexpressions of left hand sides ($2*n$ in this case) are simp'd, then we don't run into this problem.
@dysfun @tao I think the concept of simp normal form is a bit different. It means that the subexpressions of the left hand sides of equality lemmas won't change by simp, so that you can rewrite to normal form by doing rewrites bottom up.
@tao @dysfun it might be useful to have a Lean interface that tries automated tactics like simp on your goals as you type or more powerful ones in the background.
@krismicinski It indeed seems hard to say in general what partial evaluation is. It's probably at least a mapping from a program to a (hopefully) more efficient program. Static analysis may be even more vague, as it's a mapping from a program to "information about the program". OTOH "mapping from program to more efficient program" generally describes compiler optimization passes, so yeah. Actually, constant propagation and loop unrolling are intuitively a kind of partial evaluation. But common subexpression elimination, loop invariant code motion, loop tiling, vectorization, I'd intuitively say that those aren't partial evaluation...and dead code limination? Who knows.
@pervognsen A stream/video where you cover the compiler ideas you've developed would be really cool. I don't think it's even necessary to fit that into polished and prepared mini-projects. You could also just open a text editor and drawing program and explain the ideas you have. It wouldn't rule out doing the mini-projects, or write a book, later :)