Subject: Negation From: Erik Naggum <email@example.com> Date: Thu, 14 Mar 2002 21:34:21 GMT Newsgroups: comp.lang.lisp Message-ID: <firstname.lastname@example.org> Several properties of Scheme freaks puzzle me greatly. One of the worst problems I see concerns an apparent inability to deal with negation in real life. I think I have to illustrate this with an example from code: (typep 1 '(not symbol)) is exactly equivalent to (not (typep 1 'symbol)) as far as the value of the expression goes, but they test for different qualities. The first tests for memberhip of 1 in the value space that excludes all symbols, while the latter tests for membership of 1 in the value space of symbols and reports the opposite of the answer. The latter expresses "1 is-not a symbol", while the former expresses the more unusual "1 is a non-symbol". Now, to a person with only two possible values of such predicates, there can be no difference. A difference would contradict fundamental properties (axioms) of his belief system. Suppose I argue against "Scheme is a Lisp" with a one-bit person, and either deny that this is true or actually say "Scheme is not a Lisp". A one-bit person would not see this as different from "Scheme is a non-Lisp" -- because to him, there can be no such difference. I find this quite fantastically irrational, but I do not think a lack of education can have caused it. This gets even more irrational when a one-bit person wants to deny "Scheme is not a Lisp" (which he reads as "non-Lisp"). In order to establish the falsehood of a claim that something "is" a non-thing, it should suffice to point out only a few qualities that contradict the identity or membership in "non-thing", and if you can establish that it is not a non-thing, then, by virtue of the one-bit person's two-value system, it must be a thing! Of course, there is no limit to how silly this can get: What is "non-Lisp"? Leaving aside the fact that non-Lisp has all the wrong qualities, while "Lisp" has all the good ones (please remember that we deal with one-bit people) and that this causes strong emotional reactions to even weak denials of "Scheme is a Lisp", the fight they engage in more concerns getting out of the dreaded "non-Lisp" camp than into the warm and welcoming "Lisp" camp. I think the emotional processes of a one-bit person who wants Scheme to a member of the Lisp family (expressed incompetently as "Scheme is a Lisp") actually depends on so much irrational two-value logic that it results in abject fear that if they lose their ties to Lisp, they will become "non-Lisp", and that is certainly the worst possible fate. I have seen a number of Scheme freaks argue very strongly with a mish- mash of negative statements, probably thinking that _their_ negative is a positive, but the real world does not have only one bit, it is not all black or all white. The idiotic "shades of gray" does not apply, either, of course. Instead, we have lots of small things that are black to some people and white to others, like billions and billions of them. The _result_ forms a "shade of gray", but each individual decision is pretty clear to each person, at least once it becomes conscious. What I find so odd about this failure to grasp negation is the abject failure to see that every position consists of a huge number of decisions. For some weird reason, one-bit people seem to add up a lot of bits and still get back only one-bit answers. Even more frustratingly, one-bit people think that other people have only ont bit, too. So when you argue against something they believe, you argue not only against their specific argument, but against their entire _being_. To contradict a position is equivalent to contradict the entire universe as they know it. They cannot flip just one switch, but must flip them all. The only thing you can tell these people is "you need more bits!", but that does not compute in their one-bit universe. Some people think that only boolean operators should be subject to negation, i.e., the not operator, so (not #f) => #t, and (not #t) => #f, but all other arguments to not should signal an error. Common Lisp treats all non-nil values a boolean true, but not returns a canonical true, the symbol t, and several one-bit people have expressed a serious gripw with this, just as they gripe loudly that car and cdr return nil when given nil as argument, that nil and the empty list and false are the same, etc. Purity of design to one-bit people means precisely that a thing is only what it is and moreover that everything else is not that thing so they can actually reason with one-bit negation. Since the resistance among one-bit people to increase the number of bits is enormous, close in magnitude to believing in more deities, there is no resolution of this problem. One can only hope to identify one-bit people as early as possible, and since they have their own newsgroup, I think the one-bit people should _stay_ in comp.lang.scheme, where the simple one-bit logic seems to apply to everything and where they can actually be reasonably certain to be accurate if they accuse other people of thinking in terms of One True Way and the like, which is goddamn annoying to n-bit people. /// -- In a fight against something, the fight has value, victory has none. In a fight for something, the fight is a loss, victory merely relief.