Subject: Negation
From: Erik Naggum <>
Date: Thu, 14 Mar 2002 21:34:21 GMT
Newsgroups: comp.lang.lisp
Message-ID: <>

  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

  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.