Hacker News Reader

Comment by hrunt | Hacker News Reader

As someone with a software development background, I always found legal language very interesting. It is like a very verbose, programming language. All sorts of words and phrases have very specific meanings that, when arranged in a certain order, produce specific, reproducible outcomes. Sections of contracts and laws reference other sections by name and reference, and the whole document (or set of documents) gets interpreted in a semi-rigid way.

Just like computer programs, mistakes happen with legal languages, and when they do, they are typically have unintended consequences.

(edited for a couple of missing words in the last sentence)

View on HN

Several years ago I was chatting with a patent lawyer who belonged to my electronics hobby group, and it struck me in the middle of the conversation that Lawyers are hackers of the Law. Folks who find the system interesting and (in some cases) enjoy finding and understanding the attack surface and vulnerabilities.

I think the biggest difference they face is that the interpreter is another reasoning human, and not just a functional part of the machine.

I wrote an analyzer for patent claims: https://github.com/btrettel/plint

There are tons of ambiguities and other problems in issued patents!

When I get the time, I intend to rewrite a significant amount of the code in an object-oriented style. (Basically, making a class for a patent claim and having a ton of methods for that.) The code right now is a mostly untested mess that seems to produce decent results but is not pleasant to work with.

I attended a computing conference in LA a few years ago where someone presented a paper that turned legal phrases into code, and was able prove theorems from it. She suggested it was a way to mathematically look for "bugs" in the legal documents.

I thought it was the most fascinating talk in the conference.

do you have a link or reference to the paper or talk, please?

Possibly could be this:

https://www.youtube.com/watch?v=EshxZVMURt4

https://popl18.sigplan.org/details/POPL-2018-papers/3/Formal...

The city is Los Angeles, though the content doesn't seem to match precisely what was mentioned.

I found this via a Google search for `conference convert legal phrases into code "theorem" bug`, which returned the following paper:

https://hal.inria.fr/hal-03159939v2/document

I then checked the citations of that paper for anything matching.

Yes, it's the POPL talk. Thanks for digging it up for me. I had a nice conversation with her after her talk about her work.

I remember this talk! The speaker recommended doing this with the tax code because it was one of the most mechanical -- very little inherent ambiguity, there's just a lot of surface area to cover, so it's a great candidate for actually applying formal methods to.

You'll probably remember me being there, I was the nerdy guy.

Oh wait, everyone was a nerdy person!

I was starstruck enough just sitting next to Daniel Friedman ^_^;

I have felt this way as well and wonder why we can't encode laws into some sort of machine code and study it, test it, iterate it, debug it, and optimize it like we do with computer programs.

The space of things that can happen is just too large. You need a human, or some other neural network, to make judgment calls.

But perhaps we can study the past judgement calls and relate them to which words were chosen.

People tried that. Unfortunately, it was immediately doomed because it was a blockchain thing.

More seriously, this means you also have to accurately encode all the things the laws refer to, even when those things are vague judgement calls. It's easy to say "you can only have a noncompete agreement if it doesn't make it unreasonably difficult to find another job in the same industry", but hard to express "unreasonably difficult" or "same industry" with the kind of precision we expect from code. A sufficiently evil company would just pay a lawyer for a few days to find a loophole in whatever definitions you can think of.

There's a reason the primary use of this is cryptocurrency conversion - it's a lot easier to enumerate all the failure modes in "give me n of A and I will give you m of B".

> encode laws into some sort of machine code

Don't need to encode it in some sort of machine code. Just need a git repo with the law so we can submit a PR to the CA assembly and get this fixed.

Because it would end up a weird machine [0]

[0] https://en.m.wikipedia.org/wiki/Weird_machine

Thank you for this. I went down a 3 day rabbit hole learning about return oriented programming and finding this awesome seemingly open courseware class called CS 4630 Defense Against the Dark Arts [0], which eventually led to me signing up for this x86-64 assembly thing [1] when I had absolutely no idea what they were talking about by the third class.

[0] https://www.cs.virginia.edu/~cr4bd/4630/S2021/

[1] https://exercism.org/tracks/x86-64-assembly

Update: Exercism seems to only be an "exercises" platform and doesn't actually have any teaching materials of its own?

That is the greatest class name ever.

It is a fascinating idea indeed.

While Leibniz is widely known for his mathematics and philosophy, one of his lesser known ideas was the relation between law and computation.

There is a small research community around it today. Look up Computational Law and Computational Contracts if you are interested.

Reply on news.ycombinator.com