From Learning, Certainty, Causality and Consciousness


     APL is A Programming Language conceived by Kenneth Iverson in the
1960's at the IBM Yorktown Heights, NY computer center.

     APL was written to allow designers of the new IBM 360 super
computer of the time to express the algorithms implemented in the
hardware that made up the computer.

     They essentially wrote the computer in APL, before implementing it
in hardware.

     In that sense APL was a hardware programming language, however they
found once the 360 was built, that the language used to design it was
optimum for use on it in many other areas of application.

     Like many programming languages APL deals with numbers and

     It has two rather unique qualities, the first is that rather than
use names for various functions like log and sine, it uses single
characters, and thus needs a special keyboard to enter the special
symbols.  If you have ever seen an APL keyboard, you will probably
remember wondering what the hell that was.

     Second, because it has so many fundamental operators like log and
sine, there is no order of precedence in evaluating expressions.

     In most languages 3 x 2 - 1 would be (3 x 2) - 1 or 5.

     In APL, everything is evaluated from right to left unless there are
parenthesis, so 3 x 2 - 1 would be 3.

     One of the advantages of APL is that it is an interpreter, rather
than a compiled language, so one is presented with an active workspace
on the computer screen that accepted commands, executed them and
remembered them.

     A simple session might go as follows.

     Indented lines are typed by the user, unindented lines are typed by
the computer.
      A <- 3
      A <- A + 2

     The above session shows a number of important things.

     Before A has been assigned anything, it doesn't exist at all, it is
a NOTHING per the opening definitions, or a VALUE ERROR per APL.

     The opening definitions define a nothing as any object with an
empty quality set, no qualities.
     After A has been assigned the number 3 with A <- 3, A becomes a
something, its quality set is no longer empty now being the number 3.

     Once A has been assigned a number, it retains that number forever
until it is changed again, for example, in the next line by adding 2 to

     The last line where A is typed alone on the line indicates a desire
to see its value, and the number 5 is written.

     In fact any line that does not contain an assignment arrow <-, no
matter how complex, means that you want the final evaluation of that line
printed out.  Without the assignment <- however the final result is not
stored in any thing, and the value is lost as soon as it is printed.
Better to store it in A first then print it out!
     The workspace can be saved at this point and reloaded later, to find
A still exists where one last set it.

     A can also be erased, returned to a value error.

     )ERASE A
     Numbers come in many forms in APL, they start with the simple
numbers like 3 in the example above.  In that case the 3 is a scalar,
with zero dimensions as we shall see below.
     But A can also be assigned to a set of numbers like so:

     A <- 3 10 5 17
     A + 1
4 11 6 18

     In the above example 3 10 5 17 form a 4 element array called a
vector.  Vectors have one dimension, like points on a line, and can be
as long as you like, that is have as many elements as you like including
just 1 or even 0 elements!

     There are a number of operators that work with vectors to help
you handle them.

     First the regular operators like plus and minus work as you would

     A <- 2 4 6 8
     A + 3
5 7 9 11
     A + 1 2 3 4
3 6 9 12
     A + 1 2 3 4 5

     The above shows that you can add a scalar to a vector in which case
the scalar is added to each member of the vector, or you can add two
vectors together, in which case each member is added to the same member
in the other vector.  But we can not add two vectors of different
lengths, its meaningless.

     There are also more sophisticated operators like the one that allows
you to sum up the values of A

     A <- 1 2 3 4

     The construct +/A means put the + between every member of the
vector and the execute the whole line.

     A more interesting example is is x/A which puts a times between
each member and multiplies them all up.

     A <- 1 2 3 4

     Notice in APL times is x and not *.  The * is exponentiation.

     Now here is where you really need to start paying attention, for
without this you won't ever be able to talk about the proof and scalars
in any meaningful way.

     There is an operator that allows you to determine the shape and
size of any array, be they scalars, vectors, matrices, cubes or hyper
cubes and higher etc.

     It is written and called after the greek letter RHO, in this paper
we will use the small letter p to represent the RHO operator, as that is
the closest to what a RHO really looks like.  Its called RHO after
RESHAPE which is what it does.

     RHO has two uses, depending on whether it is used with one
argument or two.

     With one argument, RHO returns the shape of A.
     A <- 1 2 3 4 5 6

     This says that A has one dimension with 6 elements in it.  That's
like a one dimensional line 6 inches long.

     You know the extension is 6 because you see it right there in the
answer.  You know there is only one dimension because only one number
was printed out.

     So when you see 6 = pA, you know that A is one dimensional with an
extension of 6 inches, elements, numbers or whatever.

     When used with two arguments, B p A, RHO reshapes A after the
value of B.

     5 p 1
1 1 1 1 1

     6 p 1 2 3
1 2 3 1 2 3

     4 p 1 2 3 4 5 6
1 2 3 4

     Now the above notation opens a serious question, which is what is
the value of:

    0 p 1 2 3 4

     Well we know that the left hand side tells you two things, how
many dimensions and how many elements in that dimension.

     So because there is just one number on the left, the answer must
be a one dimensional vector, but it has ZERO elements!

    To make it more concrete let's use A again.

    A <- 0 p 6
         <- blank line

     Since A has no elements in it, when you ask for APL to print it
out, it just prints an empty line.  Notice this is not the same thing

     Just because A is an empty vector, doesn't mean it is a nothing.
Its a 'something' with one dimension, but no extension.

     Now of course in the real world, an object that was one dimension
but zero inches long, would be a material nothing, but we have to be
really careful here, because having one dimension, even if its zero
extension, makes it a something in thge language of the proof, not a

     It has a quality, namely shape, even if it has no material
existence, thus it can't be considered a true nothing which has no
qualities at all.  Shape means dimension with extension.  In this case
having zero extension doesn't mean having no shape, thus it isn't a
complete nothing.

     One more thing to notice before we move on, it clearly doesn't
matter WHAT is to the right of the RHO if the left is 0, because RHO is
going to take zero elements from the set on the right, and that's zero
elements regardless of what is on the right.

     So the following are all the same empty vector:

    0 p 1
    0 p 2 3
    0 p 1 2 3 4 5 6
    0 p 0

    In fact when someone wants to create an empty vector they often
just use

    A <- 0 p 0

     Now you might ask why would you want to create an empty vector?
Well it creates a place holder so that you can then concatenate things
on to it as you collect them.

    For example:

    A <- 0 p 0
          <- blank line
    A <- A, 3
    A <- A, 4
3 4
    A <- A, 2 4 6
3 4 2 4 6
    A <- A, 3 p 7 7 9 8 7
3 4 2 4 6 7 7 9    Notice the 8 and 7 are dropped because only 3 are
                   are wanted.

     Suppose you tried to concatenate onto B without first setting B
to the empty vector.

    B <- B, 3

     B isn't defined at all, its a true nothing, so you can't add
something to it.

    OK, let's move on.  Say you want to create a two dimensional
matrix that is 3 by 4 filled with 1 2 3 4.

    A <- 3 4 p 1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4

    You see, 3 rows, 4 columns.

    Say you want to create a cube of 3 by 3 by 2 filled with the numbers
from 0 to 17.

    A <- 3 3 2 p 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
0 1
2 3
4 5

6 7
8 9
10 11

12 13
14 15
16 17

     You see APL can't print out a cube, so it prints out 3 faces of 3
by 2 each.

     So you can see the power of RHO.

     Now let's take a look at the consequences.

     First let's review what RHO does.

     Used with two arguments it creates an object from data on the
right with shape specified on the left.

     A <- SHAPE p DATA
     A <- 2 3 4 p 3     That's a 2x3x4 cube filled with 3's.

     Used with one argument, RHO returns the shape of the object that
was used to create it.

     SHAPE = p DATA
     A <- 2 3 4 p 3
2 3 4

    So this is our first theorem of importance.

    SHAPE = p (SHAPE p DATA)
    B = p (B p A)

     Now here is the next question.
     What is the shape of the answer that RHO returns?  In other words
what is the shape of the shape of data?

    In the example above pA returned 2 3 4.  What is shape of 2 3 4?

    Well its 3.

    So we have

    A <- 3 4 p 1
1 1 1 1
1 1 1 1
1 1 1 1
3 4

     Clearly A is a 3 x 4 matrix of 1's.

     So the shape of A is {3,4}.

     We put the {}'s around the shape of an object to signify that it is
the shape we are talking about.  APL itself doesn't do this.
     And the shape of 3 4 is {2}, its a line with 2 elements right?

     And the shape of 2 is {1}, it too is a line with 1 element.
     Now here is where you ask, but 2 is a single number, why is it
considered a vector of one element instead of a scalar?

     Simply because RHO is *DEFINED* to return a vector, it always
returns a vector, it can't return any thing else but a vector.

     But it can return a one element vector or even an EMPTY vector.

     Say we define S to be a scalar, V to be a vector, M to be a
matrix and C to be a cube.

     S <- 3
     V <- 1 p 3
     M <- 1 1 p 3
     C <- 1 1 1 p 3

     We have created four objects above.

     The first is a zero dimensional scalar whose value is 3.

     The second is a one dimensional vector whose value is 3.

     The third is a two dimensional matrix whose value is 3.

     the fourth is a three dimensional cube whose value is 3.


    So what is the difference?


1 1
1 1 1

     The shape returns how many dimensions the object has, and each
element in the shape tells you the number of elements along that
dimension in the object.

     Take a 1 x 1 matrix, it is two dimensional, but has only one
element.  The shape of that marix is {1,1} which means a 1 by 1
or 1 x 1 matrix.

     Take a 1 x 1 x 1 cube, it is three dimensional, but also has only
one element, so its shape is {1,1,1}

     So you see that the number of elements that an object has is not
related to how many dimensions that object can have.

     A vector, matrix or cube can have as many elements as you wish,
including none!

     0 p 0     is a zero element vector with shape   {0}
     0 0 p 0   is a zero element matrix with shape {0,0}
     0 0 0 p 0 is a zero element cube with shape {0,0,0}

     So how do you make a zero element scalar?

     You can't.  A scalar HAS TO HAVE ONE AND ONLY ONE ELEMENT.

     A zero element scalar is a VALUE ERROR.

     So let's talk about the vector and matrix and cube a bit more.

     How many elements total does an object have?

     Well if it is a 2 x 3 x 4 object, it has 24 elements, or 24 cubic
inches, or whatever your measure is.

     Since 2 3 4 is just the RHO of the object we can write that the
number of elements in an object is

    A <- B p 1
    N = x/pA = x/B

     Remember that x/B means to multiply all the elements of B
together.  If B is 2 3 4 then 2 x 3 x 4 is 24 elements total in a 2 by
3 by 4 matrix.

     Now let's get tricky.

     We know there are zero elements in a 0 element vector.

     How many elements are there in a matrix with 0 rows and 4 colums.
That's a 0 x 4 matrix.

     M <- 0 4 p 5
0 4

     That's right, zero rows and 4 colums makes zero elements total.
Kind of stupid eh?

     So is that a nothing?  No, its not a value error, its a nothing
with two dimensions and SHAPE, namely 0 rows and 4 columns, and that
surely is not a nothing.

     But it isn't a lot of something either.

     Say someone gave you a 2 x 2 x 2 piece of gold.  That would be 8
cubic inches of gold wouldn't it.  That's a lot of gold.

     But now say someone gave you a 0 x 2 x 2 piece of gold.  That's 2
inches square on a side, but 0 zero inches thick.  How much gold would
that be?

     Zero cubic inches of gold.  Correct.

     Now let's say you are a two dimensional flatland creature, you
have no idea about the 3rd dimension, and cubic inches is meaningless
to you, but square inches means a lot.

     Say someone gives you a 2 x 2 piece of gold.

     How much gold is that?

     Well it's 2 square inches of gold, which is quite a bit, right?

     But say he gives you a 0 x 2 piece of gold.

     How much gold is that?

     It's zero square inches, and that's no flatland gold at all!

     So what is the difference between

     A 0 x 2 x 2 piece of 3 dimenisonal gold and
     A     2 x 2 piece of 2 dimensional gold?

     The first is 0 cubic inches of 3 dimensional gold which is no
gold, and the second is 4 square inches of 2 dimensional gold which is
some gold!

     So we come to our next theorem which is really important, and you
really have to get it, or you just won't get anything beyond this.

     If a physical object has a dimension, it must have non zero
extension in that dimension to order to be a physical something.
Anything with zero extension along any of its dimensions is a physical

     So the minute you take a 2 x 2 piece of gold which is a
something, and give it a 3rd dimension, you HAVE to give it non zero
extension in that dimension or it will turn into 0 x 2 x 2 or no gold.

     So if the external physical universe consists of 11 dimensions,
as the string theory boys claim, every one of them HAS to have non
zero extension in them or else the entire universe would disappear
into nothing.

     Yes APL does allow for zero extension objects to be called
somethings, they are also called nothings with shape, but physical
existence doesn't.

     In APL a object with zero extension along a dimension is
a nothing with shape.

     In the physical universe, such an object is a nothing period.

     Ok so what about the scalar?

     Well the scalar is a rough case, because it doesn't have the option
of being a nothing with shape, it has to be a something or a value
error.  You can only be a nothing with shape if you have shape!  And
having shape means having non zero dimensions.  Since a scalar has zero
dimensions, it has no shape at all.

     Further how do you create a scalar using RHO.  Since its SHAPE is
the empty vector, you have to use an empty vector to create it!

     A <- (0p0) p 4     That's why A <- 4 is so much easier!

     Notice that 0p0 is an empty vector, and remember if there is a 0 on
the left, it doesn't matter what is on the right, 0p6 would have done
just as well, its still 0 elements!
     Notice also that the above does not make A empty, it makes
A's SHAPE empty, which makes A a non empty scalar!
           <- empty vector, A's shape is zero dimensions
0          <- indicates that pA has zero elements
1          <- is always 1 no matter what

     So lets make a table out of this showing everything there is to
know about scalars, vectors, matrixes cubes and hypercubes.

     Formally the correct way to create all these different kinds of
arrays is as follows.

     S <- (0 p 0) p 5         0 dimension,         {} shape
     V <- (1 p 5) p 5         1 dimension,        {4} shape
     M <- (2 p 4 5) p 5       2 dimensions,     {3,4} shape
     C <- (3 p 3 4 5) p 5     3 dimensions,   {3,4,5} shape
     H <- (4 p 2 3 4 5) p 5   4 dimensions, {2,3,4,5} shape

5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
5 5 5 5 5
Hey I will let you figure it out!  H is a hypercube.
     Here is another formal table laying out the p, pp, and ppp of
each of the above arrays.

         S         V         M         C         H
p       {}        {5}      {4 5}    {3 4 5}  {2 3 4 5}  shape
pp       0         1         2         3         4      # of dimensions
ppp      1         1         1         1         1      always 1

     The shape has one number for each dimension showing the extension
in that dimension.  Notice the shape of the scalar is empty {}.
    The number of dimensions an object has is called its RANK.

    Notice the rank of the scalar is 0 because there are 0 dimensions
in the shape {}.
     So what have we learned?

     An object can either be a scalar with zero dimensions or a non
scalar with 1 or more dimensions, such as a vector, matrix or cube.

     If an object has one or more dimensions, it MUST have non zero
extension in that dimension in order to not be a physical nothing.

     If an object is a scalar, it doesn't have dimensions in which to
have extensions, but exists anyhow with only one element.  That one
element however can be as long or as complex as you want.

     PI is a scalar, but is infinitely long and contains an infinite
amount of data.

     One doesn't need dimension to encode data, the use of vectors,
matrixes and cubes are merely a convenience.  All of the data in the
biggest multidimensional matrix you could concieve, can all be placed
into a single number (large enough or long enough) in a single scalar.


     The ultimate question then is what is the nature of the
AllThatIs.  Is it a multidimensional object, or a zero dimensional

     Which is true?

    0 = pp Actuality or
    0 < pp Actuality ?

     It is an important question.  
     From the proof we have learned that one can not learn with
certainty about anything across a non zero extension in a non zero
dimension.  Where there is certainty, there is no extension and zero
dimension between learner and learned about.

     So where there is perfect certainty, 0 = pp Actuality.

     This zero dimensional actuality however likes to project multi
dimensional virtual realities, thus we have the following two
equations that sum up existence.

     0  = pp(Actuality)
     0 != pp(Reality)

Homer Wilson Smith     The Paths of Lovers    Art Matrix - Lightlink
(607) 277-0959 KC2ITF        Cross            Internet Access, Ithaca NY    In the Line of Duty

Sat Dec  9 01:21:40 EST 2006