This present blog post may be of interest to many of those who follow the Oracle v. Google trial, but it has a different style from my other posts, which mostly target a legal and business-oriented audience: it uses terminology and analogies that computer programmers will find easy to understand. I'll translate the logic of the procedural issues here to the logic of a sequential computer program and a stack.
I'm doing this post because I see that numerous geeks have been misled by Google, its astroturfing friends, and by reporters who are unbiased but generalized a statement the judge made for only a subset of the directions in which this litigation can go from this point.
This blog has a proven track record of getting such issues right when others (for different reasons) get them wrong. Some 15 months ago, I pointed to six previously undiscovered files that I said Google's Android codebase infringed -- a so-called "shitstorm" (pardon my geek terminology) erupted, but on Friday, Judge Alsup overuled the jury on this item and found Google to infringe eight more files, six of which were first flagged by me.
Now let's talk about what Google has won against those 37 Java APIs. The judge told the jury that it should assume (though he has yet to decide) that the structure, sequence and organization (SSO) of those APIs is protected by copyright. On that basis, the jury said it deems it infringed, but couldn't reach unanimity on Google's "fair use" defense.
Just like any other plaintiff, Oracle has to prove an allegation and prevent Google from proving any of its affirmative defenses that would defeat that allegation. We're talking about an AND operation (also called a "conjunction" in mathematical logic) that Oracle needs to win, which conversely creates an OR opportunity for Google (it just needs to strike down one of the AND-connected values to get away with what it's done).
For now we'll just focus on the question of liability. If Google is liable, Oracle can seek remedies (damages and others, particularly an injunction). If a plaintiff wants a particular remedy, he has to win liability (which depends on multiple AND operations) AND then win the remedy (for example, an injunction isn't available in the United States without the so-called "eBay" four-factor analysis). In this post, we'll just focus on liability. We'll talk about injunctive relief some other time, after liability has been established.
The multi-AND operation for API SSO liability looks like this (from Oracle's point of view):
copyrightable AND ownership_proven AND infringed AND (NOT fair_use) AND (NOT equitable_defense)
To be precise, equitable_defense is the result of a multi-OR operation. Google raised multiple equitable defenses ("we have a license", "we didn't need a license", "they sued too late", "they're evil", etc.), and in order for equitable_defense to be true, it's sufficient if even just one of the OR-connected values is true. But none of those equitable defenses has much traction so far, so we can simply things by looking at the result of that multi-OR operation as one value. By the way, the jury was asked two questions on which the judge asked the jury to speak out on an "advisory" (not binding) basis, and one of them was very critical (whether Google believed it didn't need a license) but answered negatively for Google. That reduces the likelihood of Google prevailing on an equitable defense, though it's still not 100% impossible.
We're already talking about how Google can win the API SSO liability thing:
(NOT copyrightable) OR (NOT ownership_proven) OR (NOT infringed) OR fair_use OR equitable_defense
You programmers know that there are two ways in which programming languages can interpret AND and OR operations: they can either stop once the result can't change anymore (an AND result is definitive once there's the first "false" value, an OR result is definitive once there's the first "true" value) or they can be designed (or instructed) to perform all evaluations anyway since each evaluation has an effect in and of itself. With this process, it's a little more complicated, for the following reasons:
Generally, a court doesn't want to waste time on the evaluation and adjudication of claims that are "moot". But:
Jury verdicts can be overturned by judges ("judgment as a matter of law", JMOL).
There can be appeals to higher courts. Judges sometimes like to further protect a result against an appeal so that the basic outcome may still survive even if a part of the reasoning is overturned.
Appeals courts can change parts of the operation directly (such as by saying that a JMOL was warranted), or they can remand a case by sending it back to the previous court for reconsideration or retrial. A retrial could result, for example, from a need to establish facts not previously evaluated, or because a party proves that the original jury was instructed the wrong way.
When there's a jury at work, it makes sense to have it evaluate facts even "just in case" they are relevant later, knowing that appeals can subsequently create a necessity that may appear to have gone away. Judge Alsup said clearly, well ahead of this trial, that he wanted to reach a point at which an appeal would deal only with legal questions (which are decided by judges, not juries) without having to have a jury look again at any of the facts.
So you now know that the question of whether the operation gets aborted once the result is definitive doesn't have a simple yes or no as an answer, at least not at this early stage where appeals are still possible. In some ways, it can happen, but it need not.
Even if this was an abort-at-earliest-opportunity process, Google wouldn't have reached the point only because the jury couldn't reach unanimity (a multi-AND operation among the jurors) on fair_use one way or the other. We don't know where the majority stood, nor how close the vote was. I believe the majority was in favor of throwing fair_use out, but I can't prove this. At any rate, the fair_use value now is neither "true" nor "false": it's the same as "N/A" in a spreadsheet or NULL in an SQL database. The jury didn't check either of the two answers.
The effect of such a NULL value is not that Google won. Google has the burden of proof for fair_use and can't win it without winning the jury-internal multi-AND operation or, alternatively, a judgment as a matter of law (JMOL). Google tried to win a JMOL back in the summer and failed. If it had won, we probably wouldn't be talking about API SSO at this stage. But it hasn't tried again. Oracle tried to win on JMOL, and a few days ago the judge denied it: not because Oracle was wrong but because he believes this needs to be put before another jury. Again, Google hasn't won: the fair_use value is still NULL.
As long as a value is NULL, the necessary evaluation is put back on the stack. At this stage, this means a retrial with another jury.
Oracle obviously wants to preserve the "true" value for "infringed" and just retry fair_use. Google, however, wants a chance to change the value for "infringed". Therefore, Google argues that "infringed" and fair_use are indivisible: one was Question 1A, the other one was Question 1B, and Google says that they both have to be put back on the stack. Oracle disagrees. The judge will have to decide. (If an appeals court later disagrees with whatever Judge Alsup decides on this, things may change again.)
Obviously, something being pushed back to the stack doesn't mean anyone's won or lost anything with respect to that evaluation. And so far it's not unlikely that "infringed" will stand and only fair_use will be put back on the stack. On that basis, Oracle has, at the level of the district court, completed one part of the AND operation it needs to complete.
Now we also have to talk about the order in which the multi-AND operation (or the converse multi-OR operation) is evaluated. the order in which I listed the variables is a logical one: first let's see if the thing is protectable by copyright, then if it's actually owned by Oracle, then if it's infringed, then if an infringement is fair_use, and finally if there's any other (equitable) defense.
The part on ownership may be thrown out pretty soon. Google raised it only after the trial had started, Oracle has asked the judge to toss this defense, and the judge said that Google was "mean" but he'd need help to develop a legal argument to throw it out. In the following, let's simplify things and drop the ownership_proven variable. And let's also forget about equitable_defense because that's something the judge will decide, taking into consideration what the jury said on a purely advisory basis.
One problem with the order of the evaluations is that the judge didn't decide on copyrightability ahead of trial. Both parties agree that this is a question for the judge, not the jury, to decide. Rather than merely instructing the jury to assume copyrightability, it would have made sense to be able to say affirmatively "this is copyrightable" (in which case Oracle's argument would have made a stronger impression on the jury and Google would have been seen as having lost a key argument) or, in the alternative, not to bother the jury with non-copyrightable stuff in the first place. But the district court has to think about the possibility of appeals. If the appeals court says it was copyrightable, the jury's answers to "infringed" and fair_use etc. should already be available so there's no need for another jury to convene.
Therefore, "copyrightable" is on the stack for now. We don't know when the judge will fetch it from there in order to evaluate it. The parties keep making arguments for their positions on this. A decision could come down any moment, or maybe it won't happen anytime soon.
This means we have "copyrightable" and fair_use still on the stack, and if Google got its way, even "infringed" would go back to the stack -- then everything (except for the items I dropped here because they're less likely to play a role) would be back on the stack, four weeks into the trial (!).
Just to be clear: in this context, I don't mean that this stack is a strict Last-In-First-Out structure. I used the term in its broader sense, where random access to any item is allowed. Say, a to-do list.
Anything is now possible for the order in which those two (or, if Google gets its way, three) items are processed again. The judge could look at this and decide copyrightability before anything else happens to these items. That would be the opposite of the order he originally had in mind. It would mean that if he finds against copyrightability, there wouldn't be a retrial unless an appeals court orders one for any other reason than an incomplete trial. The judge can postpone his decision on copyrightability and in the meantime have the jury work on stuff that may be mooted by that decision in retrospect, but he can't rule against copyrightability and then tell the jury "I ruled against this being copyrightable, but just in case I'm later overruled, I want you to render a fair_use verdict anyway while you're sitting here". If he moots items on the stack, he has to drop them from the stack.
Google wants everything to stay on the stack, where it can't hurt Google immediately, and for as long as possible. Oracle wants the stack to be processed sooner rather than later. That's the basic conflict. And of course they both think about whether the order can impact the outcome, though that's hard to tell in most cases.
Now you've seen how far we are from resolution of these issues. And except for a few references to the impact of an appeal, we were still just talking about the stage at which the case is before the United States District Court for the Northern District of California. We haven't talked about all of the permutations (because there are too many of them) that come into play when the parties appeal to the Federal Circuit and, potentially, on to the Supreme Court.
In the meantime, don't let anyone tell you that Oracle's multi-AND operation has definitively resulted in a "false" result. In connection with the API SSO issue (this post is only about that one, not about items of lesser importance) Google hasn't won, let alone definitively won, even one part of its multi-OR path to victory.
Not only hasn't Google won any part of its multi-OR path on a definitive basis because there can still be appeals (which can reverse values or set them back to NULL, sometimes with instructions that make a subsequent "false" or "true" result more likely than the respective other result) but Google also can't claim victory over any items that are simply back on the stack with a NULL value for now, waiting to be processed again... and maybe again... and maybe again... and so it goes until the parties settle or have exhausted all appeals.
One thing that has many people confused is that the judge said Oracle could only seek small amounts of copyright-related damages at the damages stage (Phase Three) of the trial (currently we're in Phase Two, Patent Liability). He indicated that $150,000 would be the upper limit. Simply put, that's because the judge assumed that he wouldn't stop or make any "jumps" in the sequential program that corresponds to this trifurcated (three-part) trial. If Phase Three begins while some of the values that Phase One (copyright liability) was supposed to deliver are NULL, then those can't be processed in Phase Three -- they have to be resolved later and then there'll be another trial over those damages. So once again we're not talking about a "false" or "zero" value, but about a NULL value that is put back on the stack. Oracle is trying to convince the judge that it makes more sense to evaluate all of the values and thereby replace all NULL values with "false" or "true" values before going into that phase. That's the best way to avoid that there have to be two (or even more) damages trials.
Those who try to fool you into believing that NULL is a "false" or a "true" value are the same ones who told you last year that I was wrong about those eight files. On those, the jury returned "false", the judge reversed it to "true" -- and even if an appeals court reversed that particular value or reset it to NULL, it wouldn't change anything about the fact that a U.S. federal judge with 37 years of expertise (as a lawyer and as a judge) agreed with me, which means I had a reasonable basis for those claims (reasonable doesn't mean that no one will ever disagree -- I just didn't commit any wrongdoing by expressing an opinion later shared by an impartial and reputable federal judge).
If you'd like to be updated on the smartphone patent disputes and other intellectual property matters I cover, please subscribe to my RSS feed (in the right-hand column) and/or follow me on Twitter @FOSSpatents and Google+.
Share with other professionals via LinkedIn: