rntz

@rntz@recurse.social
633 Followers
288 Following
1.7K Posts

Michael Arntzenius irl. PL design, math, calligraphy, &c.

Postdoc at UC Berkeley working on incremental computation, DB ⋈ FP, etc.

Webhttp://www.rntz.net
Twitterhttps://Twitter.com/arntzenius
cohostrntz
emaildaekharel@gmail.com

@wilbowma have you seen Michael Ballantyne's work on syntax-spec? eg https://dl.acm.org/doi/10.1145/3428297, https://github.com/michaelballantyne/syntax-spec, https://dl.acm.org/doi/10.1145/3674627

I remember being interested in micros/mcmicmac because they might solve a similar problem (defining macro-extensible macros). Is that why you're interested, or some other reason?

my unsophisticated intuition is that the type of (not-necessarily-finite) state machines over an alphabet a ought to be: (exists s. s * (s -> bool) * (s * a -> s)). so somehow equality on existentials should capture bisimulation of state machines. which parametricity models are you thinking of - do they agree with this?

I'm also interested in why this might not be the "right" notion of equality - but for what I'm doing right now it's the notion of equality I care about :P.

the right notion of equality on existential types should be something like bisimulation, right? is there a standard reference for this?
@adrake hm, pipelining is a good point. to me pipelining feels like micro-parallelism, so this might be akin to the distinction between work & span?

I've heard the argument made that hashtable lookup is only constant-time if memory access is O(1), but it's actually O(log n).

But isn't it actually O(∛n)? In a given time t, I can reach at most O(t³) space, limited by the speed of light.

@jcreed T_{m} a graded monad on C means, iirc:

pure : Hom(A, T_1 A)
map : Hom(A,B) -> Hom(T_m A, T_m B)
join : Hom(T_m T_n A, T_{mn} A)
and probably
weaken : (m <= n) -> Hom(T_m A, T_n A) or maybe it flips direction whatever

plus appropriate naturalities/laws

@jcreed yes. Graded monads are generally graded by something that has at least the structure of a partially ordered monoid (partial order is for "subtyping"/weakening - it can be discrete to trivialize this; monoid operator is for monadic join; monoid operator must be monotone wrt the partial order).

I might expect rules like the following:

Γ ⊢_m e : T_n A
-------------------
Γ ⊢_{mn} run e : A

Γ ⊢_{mn} e : A
----------------------
Γ ⊢_m thunk e : T_n A

Γ ⊢_m e1 : A
Γ, x:A ⊢_n e2 : B
------------------------------
Γ ⊢_{mn} let x = e1 in e2 : B

Is there a type system using graded monads that puts a grade on the _typing judgment_, not just on the monad type? I swear I saw something like this once, but can't find it. @dorchard ?

I am happy to announce that my colleague Paul Blain Levy has won the Alonzo Church Award.

https://siglog.org/winner-of-the-2025-alonzo-church-award/

Winner of the 2025 Alonzo Church Award – ACM Special Interest Group on Logic and Computation