Fixing Software Patents By Actually Applying Existing Patent Law

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...

Re:

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

Revisionist history at its worst...and wrong. It is a shame that neither Judge Rich nor Mr. Federico are here to explain why this is so. The 1946 Halliburton case did not strike down functional claiming, but rather interpreted the then statute to include the very limitations that were incorporated into the Patent Act of 1952.

Mr. Lemley is correct, however, that the consistent application of Section 112(f) is important to avoid overclaiming. I know of no person associated with the practice of full gamut patent law who disagrees with this very basic proposition.

While fixing global problems in the system is a noble but very broad goal, abolishing patentability of software on its own is a very good start, since it alone causes immense amount of problems, while fixing the whole system might take many years.

Not going to work.

This won't work, especially for extremely complex algorithms comprising thousands of lines of code. Such a case would require the judge to be a Masters or PhD level Computer Scientist to sort out the level of "sameness" in the supposedly infringing algorithm. I shudder at the thought of a jury going of pages and pages of C trying to compare it to a Python implementation. Software patents simply need to be done away with.

How would this affect current broa patents?

There are current patents now that are being used to sue software companies that are written so broadly that they can't be linked to a particular computer program--there is no particular implementation.

What would this new attitude of enforcing the functional claiming limitations do for those patents?

Several erroneous underlying assumptions and some suggested fixes, too

First: using issued, but voidable patents to assert that 'all' software patents are flawed, substitutes analysis of what are essentially 'straw men' for deep and very real consideration of fundamental issues. To get better software patents, insist that the PTO (a) be able to hire and (b) make strong effort to retain, competent Examiners with strong computer science (NOT programming) expertise; and also (c) build a real database of past software tools and techniques. (Hint: start with Knuth's work.)

Second: re-empower the 'doctrine of equivalents', not gut it; so a specification stating a 'limit test' need not further state whether the test measures equivalence, overage, or underrun (or 'when', 'until' 'as long as' condition limits) at and for each disjoint stage, object method, or procedure. Otherwise you encourage gaming the legal decisionmakers by porting the code and changing the functions encapsulated therein (as comment 6 shudders to think of -- why isn't the same a fear for complex electronics, or chemical syntheses of ionic hydrocarbon groups?)

Third: patents exist precisely to patent 'ideas' -- when those ideas are 'how to', not 'whether or not, to', do something. Contrary to the summary, one can patent the idea of plowing a field -- but not, thereby, the idea of killing the weeds in it and opening the soil for new planting and hydration. You just won't be able to use any method that is the same as 'plowing'(which is a 'process', therefore statutorily patentable) as described in the patent. Sure, you can't patent plowing _now_ -- because it is not original, now. Back when the first turning-iron was attached to a mold-board and both to drawing traces, well...they didn't have our modern law, then.

Finally, and in too-short a fashion: until the PTO and law get serious about addressing the difference between 'P' and 'NP' as part of analyzing software algorithms, and recognizes the importance of Order(n) and other measures of raw computability, these problems will remain. There is a very real _science_ in Computer Science, just as there is in Physics, Biology, and Chemistry -- one which deals with the instantiations realizable in the world, and not just in mathematical or other models.

Yes, we can use existing law to address the issues of "software patents"; but only as long as those doing so, work from real knowledge of the technical field. I have not yet seen a single analyst mention that there is a sub-field in Computer Science which is called, and deals with, 'Analysis of Algorithms'. That just might be relevant -- as is the historical record of what computer people have done since the 1940's, for a large part of four decades before a few savvy patent seekers realized that 'process' could include something using a computer.

Re: Not going to work.

Yes, and further, if not careful, a small modification (say changing variable names or otherwise changing the order of called functions or packaging of the software portion, as an example) might be enough to be considered a "change", even if it's just the same thing.

Software patents are very slippery at the best of times. N need to make them even more difficult to deal with.

Utter Bullshit

Software cannot be patentable and that's about it. You cannot draw boundaries between 1 implementation and a small deviation and a small deviation that optimizes a lot, and an even further deviation that makes the code nicer and suddenly it's all deviation and no longer the original. That is the main reason one should not spend energy on trying to grasp and own software.

Limitting software to a very specific function doesn't solve anything because it is a wordgame. When is something 'a function'. I can make software that has a function to help other software (which would be a library).

Now the problem obviously is that the courts, patent office and lawyers seem to think an algorithm in software is something entirely different than in mathematics. Which is bogus. Sort of like legislating the value of Pi to exactly 3 (Which was actually tried in Indiana in 1897). I can't even fathom the incredible absurdity -- and complete disconnection with science -- that view shows.

So if you really believe that software should NOT be excluded from patents, you're saying mathematics, and by extension, laws of nature, should be patentable. You can't tell me you really mean this.

In short: Yes, if the patent law as it exists would be actually applied, there would be no software patent whatsoever.

Makes sense but still doesn't fix the system as a whole. The infamous rubber effect Apple got a victory against Samsung is a good example. Any tard can come up with that effect once the tools that make it possible are in place. I'm fairly sure Samsung could change the source code (maybe littering it a bit) and achieve the same effect with different lines but the fact is, I could be oblivious to what they do and reach the same effect.

The problem goes deeper than that, unfortunately. But could be a start.

functional claiming

This is not a new idea. Regarding finding a good "test case," every competent patent attorney (defending an accused infringer) already knows to use the argument outlined above to attempt to invalidate claims in a patent (when applicable). Remember, patent attorneys try to invalidate patents in court just as often as they try to assert them in court.

So far, courts have only bought the argument to a limited extent. The idea is to convince the judges; there are plenty of "test" cases out there.

Also, just to help avoid confusion for some people, there technically is no subsection (f) of section 112 in the US patent laws. The applicable law is simply the sixth paragraph of section 112, and is usually referred to as the sixth paragraph (in contrast, other sections of the law expressly specify a subsection letter).

Re: functional claiming

When I typed my comment last evening I merely clicked the 112(f) link in what I call "cruise control" mode, and with the like title in mind made the mistake of identifying the paragraph as (f). Between my current cup of strong coffee and your comment, I realize I prepared my comment in haste, and should have paid a bit more attention to the point you correctly raise.

I do, however, restate my objection to Mr. Masnick's characterization of its incorporation into the 1952 Act as revisioninst history. Judge Rich and Mr. Federico went to great length to merely codify existing statutory provisions as then interpreted by the courts, with the functional claiming limitations having their genesis in Halliburton.

Patents - massively gut and impose yearly quota

The function of patents, as far as I am aware, is supposed to be to have practicing entities disclose information they would otherwise keep secret so that in exchange for limited protection it might eventually enter the public domain of things that can easily be known.

If you've tried looking at just about any non-example device patent recently (most of the device ones at least have to include a design schematic or working example, and thus on that basis serve the above function) you will likely wonder what crazy thing they are trying to describe. Let alone actually finding a useful design if you are searching with no foreknowledge.

So, clearly, there are both patents that are not written in a way that will be useful to future members of that field as well as far too many patents in general. The solution would therefore be to have a limited number of patents issued and only validate those which are of the highest and most useful quality. I also argue for compulsory licencing to be determined at the time of issuance; I suspect that market forces erecting an entry barrier would set more than adequate a rate to repay the actual inventor.

Oh, also, patents should only be able to be held by their inventors; though whomever hired them should also be able to require a zero-cost license in return.

Software Patents Already Invalid

My take on this issue is that, if patent laws were enforced the way they were originally intended, these problems would already not exist. Also, most software patents are in reality already illegal under current patent law. It's only lobbying for ridiculously broad interpretations of patents that is causing the problem, not really the original patent statutes.

Almost all software patents are by their very nature functional claiming, especially since anything about a software patent that is not functional claiming is already covered by copyright to the extent to which it is protectable. The few possible exceptions to this are likely to be invalid for other reasons, or only worth anything as submarine patents (i.e., only worth something if you get a bunch of people to use it first and then start charging for it later after people need it for compatibility with existing software, like LZW compression or MP3 files).

This basically makes it so that any attempt to retain software patents at all is not worthwhile. All the current uses of them are for purposes not intended to be supported by original patent legislation. In fact, they are for purposes specifically intended not to be supported.

Re: Re: Falling WAY too short

Why should software be special? Software patents are just a symptom of the whole.

Software is special because the software does not execute the patented technology. Software merely "describes" the patented technology, just the same as does the patent itself.

Patenting software is self-inconsistent in that what the patent prohibits, the description of a process (written in particular language), is what the patent regime is supposed to be encouraging. To prohibit the writing of software that implements a patented process is equivalent to prohibiting writing about the patented process. Would it be reasonable to prohibit the translation of a patent's claims into Swedish because doing so facilitates infringement by Scandinavians? If not, then why should it be reasonable to prohibit translating them into Lisp, or C, or Java? (Or more accurately, find a programmer to be infringing when the code he has written just so happens be "an equivalent thereof" the claims of a patent?)

The fixing of "non-software patents" problems requires a different approach because the nature of their problems -- whatever else they may be -- does not present an inherent contradiction between the means and the purpose of patents.

Re: Re: Falling WAY too short

Economic quackery

Lemley's suggestion might - might - have some beneficial effect but he's hardly made a convincing case that it will solve “the software patent problem”.

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.

And in my view that's a highly ironic evaluation because perhaps the most serious problem of all with the patent system is that it is applied - equally - to all fields and technologies. While its parameters and practices may be optimised for e.g. pharmaceuticals until it actually does have the overall beneficial effect on innovation and welfare in that field which is its only reasonable justification in the first place, it is quite likely to have an overall pernicious effect in others.

As a sometime 'skeptic' I've often been struck by the analogies between the way many people think about the patent system 'medicine' and its economic 'patients' and the way in which a quack thinks about his medicine(s) and his patients. One thing very noticeable about quacks is that even though many of them are decent and well-meaning folk they are prone to (unwittingly) prioritising the welfare of their 'system of medicine' and their profession over that of their patients. So when the clinical trial results showing that Oscillococcinum probably isn't any good for the 'flu come in, instead of abandoning it and moving on as an ordinary physician or medical scientist would, they make up excuses and insist that in fact it does cure the 'flu but only if it is prescribed by 'proper homeopaths' and administered in 'the right' formulation.

If software should not be patentable, then neighter should genetic DNA sequences. DNA is in essence binary code; A,T,C,G with A always connected to T and C always connected to G leaves 2 possibilies chained in sequence... looks like binary code to me (DNA => 001001001 :). Further the cell is a machine dynamically configurable to execute this code. So DNA is an idea... but frankly everything is an idea in my opinion. Somewhere, somehow, someone drew the conclusion that thinking does not require resources while building does.

So for the entertaining side note... The real problem is that as a small it developer it is very hard to compete against big companies. Patents help because it prevents big companies from just taking the good ideas on the market and copying them.