Fixing Software Patents By Actually Applying Existing Patent Law

Patents

from the one-way-to-do-it dept

Lawyer/law professor Mark Lemley has argued for years that, even as there are very clear problems with software patents, the answer is not to merely exclude software from being patentable. I tend to agree. I think it’s pretty clear that the problems with the patent system go way, way beyond just software, and as such, excluding software from being patentable would actually leave many serious problems with the patent system in place — with little interest left in fixing them. I’d rather fix the big problems across the board then look for carve-outs and “exceptions.” I’ve made many suggestions over the years for changes that I think would really help to fix the patent system, and Lemley has regularly argued that we don’t even necessarily need a change in the law. His book from a few years ago, The Patent Crisis and How the Courts Can Solve It, as you can tell from the title, argued that the courts can fix the system without a major change to the underlying law.

Lemley recently released a new paper, arguing that the problem of software patents can be dealt with by properly applying the 1952 Patent Act’s limitation on so called “functional claiming.” Simon Phipps, over at Infoworld, has an absolutely fantastic summary of Lemley’s argument, though I recommend reading Lemley’s paper itself as well. The short form of the argument is that under the 1952 Act, there are significant limitations on patent claims that cover a “function” rather than a specific solution. Phipps does an excellent job summarizing the broad concept of functional claiming:

When we say patents protect inventions, what we mean is they protect specific solutions to problems, rather than the idea of solving a particular problem. The design for a plough can be patented; the idea of ploughing a field can’t. A specific new drug that stops a headache can be patented; the function of using a drug to stop a headache can’t. Lemley explains how patent applications were increasingly written to go outside these bounds, culminating in a case in the 1940s where a judge finally declared patent claims that attempted to fence off a function — “functional claiming” — as an invalid use of patents.

However, the 1952 Act brought back functional claiming — but with very specific limitations, found in 35 USC 112(f):

An element in a claim for a combination may be expressed as a means or step for performing a specified function without the recital of structure, material, or acts in support thereof, and such claim shall be construed to cover the corresponding structure, material, or acts described in the specification and equivalents thereof.

Now, this may sound confusing, but as Lemley (and Phipps) explain, it really limits the ability to claim a “function” to a very narrow set of circumstances. Lemley provides an example of how “functional claiming” works with and without 112(f) and why it’s very limited with it:

To take an example, suppose that the patent claim includes as an element a “means for processing data.” Read literally, without reference to section 112(f), this language would encompass any possible means for processing data, including any computer, but also a calculator, an abacus, pencil and paper, and perhaps even the human brain. Section 112(f) permits the use of such functional language, but doesn’t permit it to cover any means of performing the data-processing function. Instead, the claim would be limited to the particular “means for processing data” actually described in the patent specification (say, an iPad) “and equivalents thereof.”

In other words, if you’re going to claim a function, you only get to do so in the very narrow spectrum of the “means” for which your patent applies.

Now, the problem: in the computer age, patent lawyers have realized that if they effectively show “a computer” as “the means” then they can really go back to claiming the full function, rather than the very limited function.

A patentee who claims “means for calculating an alarm limit” is invoking the limits of section 112(f), and the claim will accordingly be limited to the particular software algorithm or implementation the patentee described in the specification. But if the same patentee claims “a computer programmed to calculate an alarm limit,” courts today will read the term “computer” as sufficient structure and will understand the claims to cover any computer that can calculate an alarm limit, however the calculation is programmed.

He goes on to note a bunch of examples of the loose way that the system is defined to make software patents ridiculously broad, so they effectively go back to claiming a patent on the basic function. So you see things like “in a dating processing system,” “a computer system,” “a computer readable medium,” “over the Internet,” “one or more processors of a computer system” and so forth in patent claims. But given that pretty much everything is done “on a computer,” it should come as little surprise that these patents, which should be really limited, actually do end up claiming very broad functionality for things like… sending email, or having a shopping cart, or having a web page “bounce back” when you hit the bottom.

Lemley argues that if we actually went back to what was clearly intended with the limitations on functional claiming, we could fix the problems associated with software patents. How would we do that? Easy: require that those filing software patents also submit their source code, and the patent should “be limited to those algorithms and equivalents thereof.”

We don’t need to change the statute to achieve this result. We don’t even need to overrule existing cases. We just need to pay attention to a law that is on the books but doesn’t seem to get applied in practice. The Federal Circuit or the Supreme Court could, with one fell swoop, do away with most of the problem of overclaiming in software patents – and with it, most of the problems with software patents in general. All it needs to do is to take the statute at face value and limit functional claims to the particular way the patentee implemented that function. In the software world, the way an inventor implements a function is not with “a computer” or “a processor,” but with a particular computer program. The patent claim should accordingly be limited to that particular computer program, and ones that work in the same way to achieve the same result.

Lemley points out a side benefit to having the courts just recognize this, rather than changing the law. If the courts go back to interpreting the law this way, then it applies across the board retroactively. As Lemley says, “the idea is that the law hasn’t changed; we simply understand it better.”

Is such a “solution” possible? It’s certainly possible. Phipps quotes lawyer Andrew Updegrove, who notes that the theory just needs to be tested in front of a judge who understands the details:

What we need now is a case that presents an appropriate opportunity for Professor Lemley’s argument to be presented, and a judge that is willing to accept it.

I would imagine that it won’t be long before we begin to see some test cases. It may be years before they work themselves through the court system, but hopefully judges at the upper levels can read and understand Lemley’s paper in the interim…

Filed Under: functional claims, law, patents, software patents