From: bzs@ussr.std.com (Barry Shein)
Subject: Re: Letter asking for help with Apple from the US VP
Organization: The World
	<Bv7JI5.6s1@lerami.lerctr.org> <1992Sep27.094818.2416@fcom.cc.utah.edu>
	<RLK.92Sep28122711@underprize.think.com>
Distribution: usa
Date: Mon, 28 Sep 1992 22:42:29 GMT


To draw an analogy if I may, the problem really comes down to my
having this box of gears and sprockets and so forth out of which I
need to build a doo-hickey today.

So I reach into the box and begin piecing the doo-hickey together,
this works, that doesn't, this almost works but I need a little faster
widget with a better ratio, and so on.

Finally I have my doo-hickey.

Now the question apparently arises whether or not, inside my
doo-hickey, there is some combination/orientation of gear to sprocket
or widget to thingy that in fact may be patented.

The real problem is that it could ultimately involve my searching the
entire power set of objects and their relationship to each other in my
DH, since any arbitrary subset may be the one which is patented.

Something that makes this so difficult and easy to resist as a concept
is that there is no rational classification for orientations of
multiple widgets and sprockets exists, nothing for me to charge ahead
with and look up (assuming that something like this should be
patentable at all.)

To make this more clear, consider the following:

I have in my hands, ladies and gentleman, the universal program
generator. It is a device which cranks out legal C (whatever)
programs.

I turn the crank once and it spits out:

	<null>

That happens to be a legal C program, so I call that 0x00000000.

I turn it again and it spits out:

	;

That too is a legal C program, so I call that 0x00000001.

I crank again and get:

a() {}

Also legal, and so on and so on, billions of times. Fortunately the
scheme is clever enough that mere differences in identifiers are not
generated nor counted. To each turn of the crank I assign a number, a
classification index.

This is tiresome, and potentially infinite. However, it does occur to
me that I can bound this somewhat. Certainly I can claim that I am not
interested in any program over, say, 100,000 lines of code, or
1,000,000, whatever, these are computers, numbers like this don't faze
computers, only the clock ticking on the wall can beat them into
uselessness.

Actually, I have a very good bound: I am probably not interested in
any program much bigger, or much smaller, than the one I want to know
about...BUT...This of course assumes that I can reduce my program to
any program which is a different size, but equivalent in its
input/output. In theory that is a mathematical reduction and can be
done. In practice, it's a bit harder (tho usually not intractable, I
am probably not trying to patent an infinite loop.)

Now all I need to be able to do is generate the classification number
unique to my program and look it up to see if the classification
number has already been patented.

Somewhere in this all lies an absurdity. Why not just posit this
device, perhaps even show it is possible, turn the crank a billion
times or however many times it takes to generate all programs of some
interesting size, and send them all off for patent?

It's reminiscent of early New World discoverers: I hereby claim all
the indices from 0x00000000 to 0xFFFFFFFF in the name of the King!

Since this would seem to also be possible with electrical circuits how
do they handle this problem?

--
        -Barry Shein

Software Tool & Die    | bzs@world.std.com          | uunet!world!bzs
Purveyors to the Trade | Voice: 617-739-0202        | Login: 617-739-WRLD
Newsgroups: comp.org.eff.talk