Can Lehmann

I like building programming languages and compilers. Currently working on verijit (npub17ww…mwfs)

GitHub: https://github.com/can-lehmann/
Pronouns: he/him

Public Key

npub1khufjlz2k4dkv0fkchy6wr4v6uax0988n3g24ms58xqge7yjf2ssekj7tm

NIP-05 Address

canlehmann_at_mastodon.social@momostr.pink

Profile Code

nprofile1qqstt7ye039t2kmx85mvtjd8p6kdwwn8jnnec592ac2rnqyvlzfy4ggpz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dspuux7z

Publishing to

yabu.me

relay.damus.io

nos.lol

Author Public Key

npub1khufjlz2k4dkv0fkchy6wr4v6uax0988n3g24ms58xqge7yjf2ssekj7tm

Show more details

Last Notes

2026-05-31 16:45:13 UTC

- reply

In your fraction encoding? Fraction addition is somewhat non-trivial though, or is it constructed in some clever way to make this easier?
I just read your wiki paragraph on it and this is amazing "Rotate 90° clockwise to perform the -1/x operation, the value is -1/3." 😀

2026-05-31 16:35:42 UTC

- reply

I assume you are referring to the canceling out things and their inverses? (as in constructors canceling each other out in interaction nets / opposing turns canceling in windings).

2026-05-31 16:29:46 UTC

- reply

Yeah thats what I would call an and gate 🤣 But it does not really matter in the end since there is a theorm about them being complementary (sadly I cannot remember the name right now).
The main issue the peg system has is that afaik there is no not gate. Maybe it might be possible to extend it somehow though?

2026-05-31 16:24:36 UTC

- reply

I was asking generally. I guess the question was "Does any of the systems you looked at so far have composition?" (I realize I should have specified better 😅 )
The peg based and gate (what I call an or gate because that makes more sense to me, though in the end it of course does not matter), kind of has the issue that you cannot compose them trivially as the output is in the form of a closed string while inputs (pegs) are open strings. So you need the group theory.

2026-05-31 16:10:56 UTC

- reply

I mean the "hanging something from a wall" idea should compose pretty nicely, because it reduces to group theory (each fixed point is a variable, clockwise and counterclockwise turns are group elements and their inverses). So the picture example would be a b a' b'. Lets call that an or gate. An and gate would be a b. The inverse of any winding is (x y)' = y' x'. So you can say e.g.
(a ∧ b) ∨ c = (a b) ∨ c = (a b) c (a b)' c' = a b c b' a' c'.
You can construct a winding from this.

2026-05-31 11:20:05 UTC

- reply

Whats the story for composition here? i.e. how do I feed the output from one logic gate to the next? Usually this requires input & output format to be the same, which does not seem the case here.

2026-02-20 02:56:50 UTC

- reply

I don't think so, I have done a fair bit of LISP/Scheme things including writing a compiler and then making it self hosting in my youth though. My conclusion from that was that homoiconicity is extremely cool, though in practice taping a macro system to an existing non-homoiconic language solves most problems just as well.
(Just because we are recommending stuff, rn, I think you might enjoy https://www.youtube.com/watch?v=mQnKZr97y7A)

2026-02-20 02:43:11 UTC

- reply

I was actually not aware of META II. On first glance it looks like this is essentially a parser generator that outputs stack machine code along the way? It seems like a spiritual predecessor (though it seems quite different technically) to the crazy partial evaluation techniques we have today.

2026-02-20 02:06:48 UTC

- reply

Generally I would be interested to what extent people have explored "compiler meta theory" yet? Maybe something category theory based?

2026-02-20 01:51:47 UTC

- reply

This ties in with the idea that a compiler is a thing which lowers between abstraction levels. Abstraction levels are "closed" in some sense, i.e. one does not need to know how an abstraction level is implemented physically to execute a program. This also implies that from this perspective abstraction levels are not ordered (unlike we might commonly think, C is not really higher/lower than assembly in this view, as you could lower in both directions)

2026-02-20 01:41:46 UTC

There seems to be some link between compiler construction and emergence in complex systems. Essentially, in compilers, we (ab)use emergence to lower between abstraction levels. Does anyone know any literature that explores this?
#compiler #PLdev

2026-01-02 23:28:36 UTC

- reply

The clock is just a simple loop whose length determines the period. Currently I just hard code the period, but theoretically it should be possible to determine the minimum period from the combinatorial logic depth.
https://files.mastodon.social/media_attachments/files/115/828/096/935/991/820/original/6d68084ad94f82a2.png

2026-01-02 23:27:24 UTC

- reply

Turns out building a d latch from McCulloch-Pitts neurons is also not that hard, so it can actually also translate sequential logic now. This simple counter
reg [3:0] counter = 0;
always @(posedge clock)
counter <= counter + 1;
Results in the following neural network:
https://files.mastodon.social/media_attachments/files/115/828/085/789/725/672/original/b5158d042b1662be.png

2026-01-02 22:21:57 UTC

- reply

It only does combinatorial logic, so it is not (yet) possible to convert a processor into a McCulloch-Pitts Neural Networks.

2026-01-02 22:20:29 UTC

@npub1z8r…mrq6 Seems like you have (unintentionally) nerd-sniped me into building a Verilog to McCulloch-Pitts Neural Networks flow...
https://github.com/can-lehmann/verilog2neur

2026-01-02 19:57:19 UTC

- reply

I imagine using it for music is a bit harder though, since you need to get the wire lengths exactly right for the timing to work out.

2026-01-02 19:54:30 UTC

- reply

Yeah, I think I first saw it because someone actually made a Minetest/Luanti mod using wireworld as a redstone replacement. Never played around with the mod, but I still think it was a neat idea 😃

2026-01-02 19:48:28 UTC

- reply

Sadly unable to find it right now, but I seem to remember some tool where you can layout rhythms by drawing cycles on a 2 dimensional grid. A "program counter" travels along the cycles playing any placed sounds it encounters. This means that the length of the cycle is the duration of a loop. It seems like it might end up feeling similar to that. While the actual positioning is of course irrelevant with neurons, you would probably end up building similar cycles which trigger sounds.

2026-01-02 19:35:18 UTC

- reply

Has anyone built a music livecoding tool based on this yet? (I assume that's where your kickdrum example is going)

2025-12-13 20:55:17 UTC

- reply

(well, ok, maybe the reasoning is more in the other direction. I am working on metajit.cpp for a research project and thought it might also be a good fit for writing a UXN jit).

2025-12-13 20:53:56 UTC

- reply

That's why I decided to not write the JIT by hand 😉

2025-12-13 20:16:55 UTC

👀 I am currently recovering from an illness and decided it might be a fun idea to develop a just in time compiler for UXN while I wait for my health to improve. Decided it might be fun to post some updates along the way: https://github.com/can-lehmann/uxnjit