We all agree that math isn't patentable, so let's assume that. As math is not patentable, no mathematical theorem, proof, or function is patentable. All processes that exist entirely in software are representable as a series of mathematical operations. Therefore, software methods are math. As math isn't patentable and software is math, software must also not be patentable.
This is where your argument breaks down. This is not logically sound.
Just because something is representable in some other form, does not mean it is that other form.
The interactions of subatomic particles can be represented by a series of feynman diagrams. It does not follow that interactions of subatomic particles are actually feynman diagrams.
If you want more examples, there are plenty of things in physics that are representable as interactions and models that are provably do not occur that way in the physical world :)
instead of "are representable by a series of mathematical operations", you want to say "are in fact, a series of mathematical operations "
Even then, the argument doesn't hold because they aren't patenting processes in software. They are patenting processes (which is valid), particular instances of which happen to be represented in software.
There are good arguments for why software patents should not exist. Most of them deal with abstractness of the processes or claims, not "mathiness".
Right, there you can say "ceci n'est pas une pipe" and be right. The problem with this is that software is, literally, information. And all types of information are equivalent. It's true that information requires a carrier (language, memory, hardware, whatever), but that doesn't mean it should be conflated with it. With math, numbers are no different than any other form of precise information.
Then, when someone tries to tell us that math isn't just numbers, were going to have to introduce them to https://en.wikipedia.org/wiki/G%C3%B6del_numbering
But wait, software is just numbers too, right? Right, which is why people can make this: http://us.metamath.org/
P.S. While you're over there, don't miss the 2+2=4 trivia: http://us.metamath.org/mpegif/mmset.html#trivia
"We used to think that if we knew one, we knew two, because one and one are two. We are finding that we must learn a great deal more about 'and.'" — Sir Arthur Eddington
While many physical things can carry information, I have yet to see a good argument that they are information, though a great many things can be made to carry information in one way or another.
Granted, I suppose there are some who think that we might all live inside a computer simulation, but let's not go there.
It's also a lot harder (perhaps provably impossible) to defend. There is provably nothing you can do in software that you can't do, much more slowly, with pencil and paper. The only way software can be anything other than math and calculation is to define it as something other than software, and what does that actually buy you? If we make that which you define as software patentable, but make what is commonly known to everyone else as software unpatentable, is that a satisfactory outcome to you?
I just think it's somewhat arbitrary to say that software is nothing but information. Yes, you can state that, and we could all agree to honor that distinction as such, but I think there's nothing a priori about it.
Sure, you could work out software problems on a chalkboard, but I would say doing so is different than creating a piece of software that does the same thing... in the same way that a story that is told verbally from one person to another (and not stored say, via video) is different than a book.
As opposed to what? It is nothing but information. It has no corporeal existence. Even if you put it on a disk or a piece of paper, encoding information into a medium doesn't make it not information (and shouldn't cause it to become patentable when it wouldn't be otherwise) any more than it would for other information like a song or a photograph or English text.
> Sure, you could work out software problems on a chalkboard, but I would say doing so is different than creating a piece of software that does the same thing... in the same way that a story that is told verbally from one person to another (and not stored say, via video) is different than a book.
OK, so one exists in your mind and the other exists on paper. You can draw that distinction if you like, but what is it supposed to change? You can't patent the verbally passed down story or the book. And I think the attempt really exposes the charade of software patent claims that attempt to avoid unpatentability by claiming the physical encoding: Can you really patent the information in a book just by claiming it as a physical object encoded with that information? It seems ridiculous. But that's apparently how they justify software patents.
You could define information as state or data, and software as that which acts upon that state or information. You wouldn't (or at least I wouldn't) describe the data in a cookie as software. That's just a piece of information. The browser that handles it is a piece of software. Same with http packets. That's data. Accepting dynamic bits of data and acting upon them accordingly would then be software. Or a database is software, but the data it contains is information. You could counter-argue that the cookie or the packet are not external to the system... that's it's all part of the same piece of software. And I frankly couldn't refute that, because it's just how we somewhat arbitrarily choose to define and parse our understanding of the system.
In answer to your question, software that contains no information (at least looking at it this way) would be something that runs without ever storing, emitting, or accepting dynamic bits of information.
While a recipe card might not constitute a "program" in most contexts, if you construct a cooking robot, the same data is now magically software because the robot could use it to cook. So the line you are attempting to draw between software and data is merely that of the limitations of what the system can process.
And all programs are ultimately processed as data by the instruction loop within the CPU. For example, I can construct the "non data" program of 0x20FE (unconditional branch to its own start on the 86HC11, i.e. 10 GOTO 10). The CPU unconditionally fetches the instruction at the instruction pointer, then executes it. In this case, it increments the instruction pointer by 2 while reading it, then executes and decrements the instruction pointer by 2, endlessly looping over the same data.