software patents -- the solution (from eight years ago)

Looking back at this rant I wrote eight years ago (and again, more recently), I'm thinking it was the right idea.

First, the source code is published with the algorithms in either flowchart or pseudo-code expression, and copyright is registered.Both the algorithm and the source code are annotated to show (and demonstrate) the relationship between them. Also included is a set of state diagrams, demonstrating the behavior as an algebraic automaton (a virtual machine which can be instantiated by being run on real hardware) or a collection of such automata.

Copyright protects derivative implementations. It does not protect from independently created implementations, or independent expressions of the algorithms but that's a separate issue. 

The source code and algorithm, with annotation and state diagrams are then included in the patent application, which is submitted on the same day, with the details of the copyright registration. Or the patent application might be started early, but would require the published, copyrighted source code before anything beyond a preliminary examination could begin. Time limits between the preliminary submission and the full submission would have to apply.

The algorithm would not be claimed, but would be used to demonstrate the claims. The state diagrams themselves would not be claimed, either, nor would the algebraic automata described by the diagrams. (Automata are definitely math.) Nor would the source code itself be claimed. (That's literature, and better covered by copyright anyway.) The implementation, as expressed in the source code and described by the state diagrams and algorithms, test results, run-time environment of actual implementation, and other documentation, would be only thing about the software claimable. Only one implementation or one set of implementations, limited by the source code and further limited by the documentation supplied.

This is going to be a bone of contention, but the algorithms must not be used to expand the claims. Never. Quite the opposite. They must be used to limit the claims. The claim must be on the intersection of the source code and what the other documents claim it is supposed to do, not the union.

For example, if I invent a new language, the language itself can't be patented. It's math. Any college with decent coursework covering abstract algebra will have a class on mathematical languages, and part of that coursework will take up programming languages as mathematical objects. Programming languages are mathematics.

It would not be unreasonable, perhaps, to allow a person who really wants to patent his or her compiler or interpreter to do so. But the patent should only cover the actual inventions of the author of the compiler/interpreter. If the patent is allowed to expand to the algorithms, that is patenting math.

So the patent must be restricted to the implementation of the language expressed in the real source code that the author has actually produced. Not on something he or she will theoretically produce next year. Next year's work must wait until it is actually running to be patented.

Moreover, if the symbol table uses a new hashing technique that some other programmer re-purposes to image processing, the source code implementing that technique must not be allowed to encumber the other programmer's invention in the field of image processing. (There might be an exception where the use in image processing includes the whole of the interpreter claimed in the patent, running per the claims of the patent documentation, but I'd be hard pressed to imagine how that would work.)

So the patent must be considered limited by the algorithms and other documentation, not expanded. (And expanding is what is happening in all too many cases right now.)

There is one more thing I hesitate to add here, because it will be bait for people who believe in magic to call me crazy. But algorithms can be mapped to seemingly unrelated algorithms in many cases. This is more math, stuff you study in abstract algebra (including topology and such). If we don't make the algorithms and their descriptions restrictive, clever talking lawyers could quite literally use a mapping of one apparently new algorithm to effectively put a tax on all new developments in every field of software application for the next twenty years.

(Or worse, but I'm not going to push my luck by trying to explain it here. But RMS was right.)

As I have mentioned elsewhere, without reference to the run-time operating environment, including libraries, compilers, and descriptions of the hardware under which testing was performed and conformance to the algorithm and state machine description confirmed, the claims would have to be considered weakened.

Test results could, I suppose, be appended to the patent after approval, or as a re-submission if the application is initially denied, along with the bug fixes.

In fact, all corrections to the algorithm/state machine and the source code would be required to be regularly submitted to keep the patent strong. Falling too far behind would cause the strength of the claims to be relaxed.

Independent expression would still not be protected against. But that is not a problem because patents are not supposed to be too broad, and software is a literary endeavor anyway.

Literary works are inherently abstract, and patents on abstract things cannot help but be too broad to co-exist for very long with a free society (per the US bill of rights protection of free speech). Patents on abstract stuff are incompatible with a government that recognizes freedom.

The literary work issue is a central element of the software-is-maths argument, by the way.

Hmm. Patents themselves are incompatible with freedom. So is copyright. That's why the US Constitution requires limited time, and why the limits are supposed to be reasonably short.

Author lifetime copyrights are way too long. The longer each patent or copyright exists, the more cumbersome maintaining it becomes in a free society, and the more it interferes with the function of the free society. Lifetime plus 70 is guaranteed to expose the US Constitution to forces beyond its checks and balances. The advocates of strong copyright should be questioned for their allegiance to the US Constitution.

Back to patents, the above would require changes to the patent law, but they would be the least intrusive changes possible to allow software patents and remain compatible with the original intent of US patent law (though not with the last twenty years of free-for-all dibs on ideas).

Popular Posts