Contemporary software patents are problematic because they are often overbroad. This Article offers a novel explanation of the root cause of this overbreadth. Patent law suffers from a functionality malfunction: the conventional scope-curtailing doctrines of patent law break down and lose their ability to rein in overbroad claims whenever they are brought to bear on technologies, like software, in which inventions are purely functional entities.
In addition to identifying the functionality malfunction in the software arts, this Article evaluates the merits of the most promising way of fixing it. Courts can identify algorithms as the metaphorical structure of software inventions and limit claim scope to particular algorithms for achieving a claimed function. However, framing algorithms as the metaphorical structure of software inventions cannot put the scope of software patents on par with the scope of patents in other arts. Most importantly, the recursive nature of algorithms and Gottschalk v. Benson create to-date unappreciated problems.
TABLE OF CONTENTS I. INTRODUCTION II. THE INVENTION-STRUCTURE EQUATION A. Structural and Functional Claim Limitations B. The Overbreadth of Functional Claims 1. Reaching Beyond an Inventor's Contribution 2. Reaching Toward Markets 3. Plugging up Spillovers C. The Hidden, Unified Design Principle 1. Patentable Subject Matter 2. Functional Claim Limitations 3. The Written Description Requirement D. The Limits of Enablement III. EXPLAINING SOFTWARE-PATENT OVERBREADTH A. Software Inventions Are Functional All the Way Down B. The Functionality Malfunction IV. ALGORITHMS: A VIABLE SOFTWARE-SPECIFIC PATCH? A. The Invention-Algorithm Equation B. The Federal Circuit's Tentative, Uncoordinated Steps 1. Algorithms as Corresponding Structures 2. Algorithms as Possessed Inventions 3. Algorithms as Indicators of Particular Machines C. Are Algorithms a Patent Medicine? 1. Uniformity 2. Recursion 3. Gottschalk v. Benson V. CONCLUSION I. INTRODUCTION
Software patents are overbroad. Compared to patents in other fields of endeavor, they routinely grant inventors rights that extend further beyond the technology that an inventor has actually invented and disclosed. (1) The blame for the problem of software-patent overbreadth has at times been placed squarely on the shoulders of the Court of Appeals for the Federal Circuit. The Federal Circuit has dropped the ball, so the argument goes, in that it has failed to employ patent law's well-developed tools for curtailing permissible patent scope in the software arts. (2) Given this explanation of the problem, the solution seems self-evident and eminently achievable: the Federal Circuit must simply step up and use the tools that are already at its disposal to curb the scope of software patents.
This Article offers a different explanation for the overbreadth of contemporary software patents. The root of the problem is not that the Federal Circuit has failed to deploy in the software arts the well-developed doctrinal tools for curtailing patent scope that it already uses in other arts. To the contrary, the most important of these tools is not effective in the software arts. Software is intrinsically different from most other patentable subject matters in a way that matters. It lacks the metaphorical bolt onto which patent law's primary scope-restricting doctrinal tool can attach to gain purchase and ratchet in permissible claim scope. By demonstrating that the problem of software-patent overbreadth goes deeper than has previously been recognized, this Article does more than identify a new cause of a known problem. It also counsels greater skepticism toward the existence of a simple, judicially administered solution to the problem. The problems that plague software-patent scope cannot be remedied as easily as many suggest they can be, and the anomalously high costs of contemporary software patents are unlikely to ever be eliminated.
To explain why patent law's conventional scope-curtailing doctrines are ineffective in the software arts, this Article articulates and defends two premises. First, it identifies the principal mechanism through which patent doctrine allows judges and examiners to successfully curtail permissible claim scope in technological arts other than the software arts. There is a distinction between the structure and function of an invention--that is, a distinction between the physical form of an invention and the behaviors that an invention can exhibit, respectively. Building on this distinction, patent doctrine makes what this Article calls the invention-structure equation: it holds as an ontological matter that an invention "is" its structure and that an invention's function is more peripherally only what an invention "does." (3) The invention-structure equation, in turn, gives rise to an effective tool for curtailing permissible claim scope. Patents that recite enough of the physical, structural properties of what an inventor has invented as claim limitations are valid because they are limited in scope to an inventor's invention. However, the flip side of the invention-structure equation is that functional claims--that is, claims that only recite the behaviors of an invention as limitations--are not valid. Construed literally, functional claims encompass all structures that are capable of performing the claimed behaviors, meaning that they reach beyond the structures conceived and disclosed by an inventor and thus beyond an inventor's invention. In sum, the invention-structure equation is a doctrinal tool that courts use to invalidate broad, functional claims and rein in permissible claim scope in most arts.
The second premise addresses the intrinsic nature of software as a technology: software inventions are pure functionality. Software is a powerful technology precisely because it has been engineered at a deep level to ensure that the specification of functional properties does not require the specification of any physical, structural properties. Software inventions therefore cannot be defined with reference to the physical, structural properties of either a tangible copy of the software on a storage medium or a computer programmed with the software. They can only be defined by their behavior or function. They are functional entities "all the way down" on all relevant levels of description. (4) It makes no sense to talk about the physical, structural properties of a software invention when identifying what a software inventor has invented. (5)
The juxtaposition of these two premises--namely, the invention-structure equation in patent law and the intrinsically functional nature of software as a technology--lays bare the root cause of the contemporary problem of software-patent overbreadth. Permissible claim scope is usually tethered to the structure of an invention, but purely functional technologies like software have no relevant structure to which claim scope can be tethered. The only way to fashion a viable claim to a software invention is to employ purely functional claim language, so the prohibition on functional claims that reins in claim breadth in other arts cannot be used to rein in claim breadth in the software arts, at least without eliminating effective patent protection for software altogether. This doctrinal failure is what this Article calls patent law's functionality malfunction: the invention-structure equation is ineffective whenever it is brought to bear on inventions, such as software, that are pure functionality. The invention-structure equation suggests that the three most important concepts to keep in mind when understanding how patent doctrine usually curtails patent overbreadth are "structure, structure, structure." In contrast, the three most important concepts to keep in mind to understand the nature of a software invention are "function, function, function." It is this mismatch that gives rise to the functionality malfunction and that leads to overbroad claims in the software arts.
Tracing the problem of software-patent overbreadth to the functionality malfunction is important in two ways. First, it breaks new ground by demonstrating that most of the conceptual heavy lifting required to identify the cause of software-patent overbreadth cannot be accomplished through greater scrutiny of software patents in isolation. Instead, what is needed is a better understanding of how patent law regulates permissible claim scope as a general matter in other arts. Conventional wisdom identifies enablement as the most effective tool for reining in overbroad patents. (6) This Article upends this conventional wisdom, arguing that the invention-structure equation is the most effective tool, at least when the source of the overbreadth is functional claim language. (7) In part, this inversion follows from understanding the shortcomings of the enablement doctrine as a means of curtailing the type of overbreadth created by functional claims. (8) In larger part, however, it follows from recognizing just how pervasive and fundamental the invention-structure equation is in contemporary patent law. The invention-structure equation undergirds at least three patent doctrines: the exclusion of claims to "principles" or "abstract ideas" from patentable subject matter under section 101, (9) the section 112(f) rules of means-plus-function claiming, (10) and the section 112(a) written description requirement. (11) These three doctrines are usually addressed within isolated analytical silos, perhaps because each has its own distinct linguistic formulation and statutory grounding. This compartmentalization has masked the importance of the invention-structure equation, allowing one of the fundamental design principles of patent law's regulation of permissible claim scope to pass below the radar of patent courts and commentators. (It is for this reason that this Article has to coin the name "invention-structure...