The Robb Report

Ugh. I ran into another little exception when looking at one small part of modeling legal citing: Certain words receive one abbreviation when used in one sense, and a different abbreviation when used in another. One example is Northwestern. According to ALWD, the word is abbreviated differently depending on whether it refers to the geographic region, or the university. (!)

Now how in the world is this supposed to work? The problem here is that a piece of software — an “abbreviator” — can’t simply correctly abbreviate words “in a vacuum”, without more information about them. And that gets complicated — how should this information be represented and transmitted?

This lead me to the idea that maybe software ought to act like an intelligent high school student. That is, possessing a lot of ability, but not a whole lot of wisdom.

The program would act like someone you could delegate work to, but who would need to check back with you occasionally for judgment calls. And with a high school student as assistant, you’d want to have a protocol worked out for how questions will be asked and answered — so that the process is smooth and not annoying.

If you’re a programmer, you might see where I’m going with this: The “abbreviator” mentioned above is the high school student. It’d do the normal thing 98% of the time. And when there’s an exception to a rule that it doesn’t know how to handle, it’d have a way of responding back to the main program with a description of the extra information it needs. Maybe the main program would have the information (e.g., know whether the citation refers to the university). In that case, it’d answer the question, and the abbreviator would continue. But if the main program wasn’t designed with this piece of info, it’d in turn ask the human, the end user: “Do you mean the university or the area of the country?” And then it’d send the info back to the abbreviator subprogram.

So it sounds like I’m talking about designing an architecture based on a chain of intelligent high school students.

The key idea: When a program gives some kind of result, it should be able to say how it came up with that answer - what rules did it apply, in what order, and why. If a reference was consulted, which one?

Basically, software should be held to the same standards we have for people, especially in the field of law. Here’s what that might look like. This is, again, the “development” interface… an end-user would see something much fancier:

>> Abbreviation.abbreviate 'Chief Justice'
=> "C.J."
>> Abbreviation.rule
=> "Appendix 3"

It’s a start.

As far as the technical implementation, I’ve been considering rule-based systems, prolog-based systems and object-oriented decomposition.

I’m intrigued by the idea of applying artificial intelligence to law and legal writing. The ALWD Citation Manual is an amazing document that makes a great starting point for developing interesting applications: it’s highly organized and presents the information in a structured taxonomy of “rules”.I began to wonder what it’d take to write tools that’d help create legal citations as well as validate them? And so I’ve started a Ruby on Rails app that handles just one small part of the puzzle: correctly abbreviating words in a citation. Here’s the simple web app managing the database of abbreviations. You might recognize this as the start of the table at Appendix 3(E).And I’ve created the programming for applying the rules of Appendix 3(E):

>> Abbreviation.abbreviate 'Advance'

=> "Adv."

>> Abbreviation.abbreviate 'Advanced'

=> "Adv."

>> Abbreviation.abbreviate 'Advancing'

=> "Advancing"

So, this has been pretty interesting. Now I need to handle plurals well. This, though, means I’ll have to be able to identify plurals… but I have a couple of good ideas about how to do this.