Comments

• markcmarino

  February 2018 edited February 2018

  @difranco I feel remiss at getting to this so late. I am fascinated by the analogy you draw between programming and law here.

  To understand your approach better and to move us toward some code, I wondered if you could set up the example from your paper and also share the python implementation for our further analysis:

  4.2 Example Preliminaries
  As an elementary example, consider the following code to compute the transitive closure of a graph (phrased in terms of the elementary Prolog programming example about recursively finding ancestors of a person given a set of parent- child relationships):

  ancestor (A, B) :− parent (A, B) . ancestor (A, B) :− parent (A, X) , ancestor (X, B) .
  

  That is, A is an ancestor of B either if A is a parent of B, or if A is a parent of another X and X is an ancestor of B.
  We can use this as the basis of a simple example to test the effects of an adaptive evaluation strategy. To represent the effects of sparsity of the search space, which is the main obstacle that adaptive evaluation is meant to address, we add additional rules that confound the search, like so:

  ancestor (A, B) :− parent (A, B) .
  ancestor (A, B) :− deadend (A, B) . 
  deadend (A, B) :− deadend (A, B,
                                    100000000). 
  deadend (A, B, N) :− N1 i s N − 1 , N > 0
                                  −> deadend (A, B, N1) ;
                                        f a i l . 
  ancestor (A, B) :− parent (A, X) , ancestor (X, B) .
  
  

  Can you explain ths Prolog here briefly?
• melstanfill

  February 2018

  @difranco said:

  In the law, there exists a distinction in notions of justice between justice arising from the correct procedures having been followed and justice arising from the correct outcome having been reached. The same distinction exists in programming techniques, where most focus on describing the algorithm (procedure) explicitly, and leaving the outcome (goal) implicit, but some techniques (called declarative) invert this, and describe the goal explicitly, and only implicitly derive an algorithm to reach the goal.

  In both law and software, the focus on procedure has come at the expense of reaching the desired outcomes.

  I suspect I don't have anything helpful to contribute here, but I wanted to tell you how useful I found this. I'm in the early stages of a project that is exactly about this tension--applying the same procedure in all cases does not in fact produce just outcomes. My context is whose intellectual property is protected and whose isn't, and how it means something different, say, for a Black artist to "steal" rock music for a hip-hop sample than it did for white rock artists to steal Black blues in the first place. Mechanically applying procedures can't account for that, but the law nearly always works by procedure rather than outcome.

  Ultimately it's my hope to do something algorithmic with it--if humans decide Black music is uncreative 20% more often than white music, can we account for that by adding 20% to a creativity score? To technologically reproduce, but also improve upon, human judgments by counteracting the biases built in--by paying attention to outcome at the expense of procedure.
• markcmarino

  February 2018

  One base text you might want to start with that does a bit of connection between source code and legal codes is Lawrence Lessig's Code. Might serve as a foundation text.

  Lessig, Lawrence. Code: And Other Laws of Cyberspace, Version 2.0. 2nd Revised ed. edition, Basic Books, 2006.