math joke -- 13 is a broken 10

ENERGY IN SYNCHRONOUS COMMUNITY **********PICFORM = Patterns In Contexts Formalized Epistem o logic al LANGUAGE*********** CU nu = subset union intersection union :. I DO TOO cnnu = cmu = subset intersection intersection union. ************************************************************ Also, P represents a HOHMAN ORBIT TRANSFER in SPACE SCIENCE and i represents the square root of negative one, which means a juxtaposition perpendicular to one in the Z axis. Z stands for ZALEN which means INTEGER. INTEGERS are the PRIME NUMBERS 1, 2, 3, 5, 7, 11, . . . etc and their commonalities of multiples with themselves and with each other. PRIME NUMBERS ARE NUMBERS ONLY DIVISIBLE BY ONE AND THEMSELVES, meaning they are not divisible, meaning they are the balance points in the UNIVERSE. Enjoy! 3.14 . . .blah That is actually considered to be a series. A series of computer malfunctions. Pi is a ratio described by the word GOD G is a counter clockwise spiral with an arrow on the end. O is the front view of the spiral as a unit circle in trigonometry. D is the distance around to the distance across. Therefore GOD describes the notion of Pi. ************************************************************************************************************* 3.141592653

Copyright 12/30/2005 Justin Coslor

Surjective to Bijective

(See my 5/31/2005 essay on "Patterns In Contexts Cognition" in my book "Possibility Thinking: Explorations in Logic and Thought @ http://frdcsa.org/~justin )

Base.Level.Group.Offset is the same as BASE.EXPONENT.COEFFICIENT.OFFSET.NETWORK where NETWORK is represented by the context of the polynomial. representation can convert any unique Integer (... geometric version is a numberline) or Real (... geometric version is pyramidal scaler edge juxtaposition sequence summation) or Complex (... geometric versions is Sine Spiral Graphing) number system into an infinite number of equivalent (potentially recursive) Base.Level.Group.Offset representations that all are equivalent to that orignial unique number. Cross Domain Relations for Alternate Route Mathematics can convert any of those equivalent representations back into the original number as long as you remember which origninal number system context that the alternative representation was translated from. Depending on the context of the reasoning engine, only one alternative representation will be optimal to suit whatever calculation or recontextualization or storage mechanism that the Reasoning Engine is applying or juxtaposing the original number into. Storing the original context (i.e. label of the original Number System that the alternative representation(s) come from) of the number is only an extra 2 bits in binary. For instance, in binary, 00 would mean that it is in its original context (original number system representation), 01 = Integers, 10 = Reals, and 11 = Complex. So if thte original number is a very large number, or even a small number, 2 extra bits isn't going to make much of a difference in its data representation size, especially considering that the alternative representations in Base.Level.Group.Offset can be recursive, which allows for unfathomably enormous data compression. So from now on I think it would be best to talk in terms of Context.Base.Level.Group.Offset notation since we can use this technique for more than just number systems, but for representing different scaler quantification representations of qualitative and other first principle dimensions, such as for use in PICForm/PICVis. That is how to Cross-Domain relate numbers represented in different number system contexts for doing alternative route mathematics for optimal data representation in finite state machines such as computers, and other kinds of Reasoning Engines. Let me reiterate that it is simply done by remembering the original context via adding a Contextual Origin tag (for number systems this would be a 2-bit binary tag, for other contexts it might be a PICForm/PICVis element or aspect) onto the front of every number (regardless of whether it's an Integer, Real, Complex, Base.Level.Group.Offset number, or whatever, or even a concept or context element or aspect and not even necessarily a number, because there are all sorts of kinds of calculations, such as word equations, metaphors, etc, they're all just juxtapositions, and sometimes are simply juxtapositions of dimensional (i.e. first principle) possibilities). In this way, any and all surjective relations can be turned into bijective relations (as long as there is no actual data loss).

The general algorithm for Base.Level.Group.Offset is ((Base^Level)Group +/- Offset), and is represented as Base.Level.Group.Offset, with an additional dot between each number representing each additional level of recursion. Parity is dealt with by adding an additional bit onto the beginning of each component, where a 1 means that the component is positive, and 0 means that the component is negative. In that way, decimals (and reals partial number in any base) and fractions and negative numbers and positive and negative offsets can all be represented in that format, and the resulting binary equivalency of the Base.Level.Group.Offset number is only 4 bits larger than without doing that. Coupled with the additional 2 bits to represent the Context, the number is only 6 bits larger in size to represent a Context.Base.Level.Group.Offset number, yet due to the potential for making recursive numbers, an additional 6 bits is not much difference for a nearly infinite level of size and precision potential using not much data whatsoever. The recursive versions look something like this:

(Context).(Base).(Base..Level..Group..Offset).(Base..Level. .Group..Offset).(Base..Level..Group..Offset), but the parenthesis are unnecessary, and it'll usually be assumed to be unnecessary to add a context tag onto the base tag, and even recursive components don't necessarily need a context tag either unless you find them helpful for calculation techniques, nd each additional dot indicates that an additional level of recursion. A numeric example would be something that looks like:

01.1111.11111111..11111111..11111111..11111111.1111..111111 11..11111111..11111111.1111..11111111..11111111..11111111

That could represent a number that was originally an integer that when represented using normal binary would require an utterly ridiculously larger number of bits bits to represent than in recursive Context.Base.Level.Group.Offset notation, and this example only uses two levels of recursion.

Here's an example of a quantitative translation of a PICForm object:

NumberOfBeans.1111.11111111..11111111..11111111..11111111.1 111..11111111..11111111..11111111.1111..11111111..11111111. .11111111

That's how to represent a ridiculous amount of beans in a particular quantitative way, even though a ridiculous number of beans can be represented in literally any way imaginable (whether quantitatively or otherwise) since it's all made of energy or information (Patterns In Contexts) anyway. There are an infinite number of ways to perceive of Beans, or anything else for that matter, but what's important is the original context, not how whatever it is is recontextualized into an alternative perspective of representation, because if you know the original context, then all perspectives (all recontextualizations) can be interchangeable, as long as there is no data loss in any of the recontextualizations.

Remember the equation is (((Base^Level)*Group) +/- Offset) = it's equivalent representation in whatever Original Number System or Contextual Origin that it is a lossless translation of.

Now if you want to elimate some hassle and conserve on disk space, then you should probably represent the entire number all in the same base and all in the same context, even if the representation is recursive. For instance here's a an Integer.Base10.Level.Group.Offset number that isn't even recursive:

01.1010.12348901235012378.1234089123740789.0234412304898 Integer.Base.Level____________.Group___________.Offset_______

Here's a two-level recursive Integer.Base2.Level.Group.Offset number:

01.10.1010101010010..1010111101100..1101010100.10101010100101.. 10101010110110..10101010101110.10101010011..101110110101.1011010101010

Now if you wanted to represent that number in normal binary good luck, you'd have to use a ridiculous amount of digits (zillions of digits or more).

And if you wanted to represent it using normal integers it would take slightly less digits (but would at least take a bajillion elephantillian integer digits or more to represent). This demonstrates the power and massive efficiency of recursive Level.Group.Offset number representation (which also speeds up arithmetic because it pre-chunks numbers into equations, so you can manipulate equations instead of just manipulating raw numbers).

------------------------------------------

------------------------------------------------------------------------------------ Copyright 12/29/2005 Justin Coslor

My book is now online for anyone to read in good intent.

(See my Friendly Intelligence writings for License parameters.)

http://livejournal.com/~justincoslor is my webpage, and there anyone can read the rough draft of my book "Possibility Thinking: Explorations in Logic and Thought". Only the rough draft is currently available but I'd like to turn it into some sort of WIKI or something.

Special thanks to the 61c Cafe and its wonderful patrons and staff, and to the other local Pittsburgh coffee shops for great coffee, great music, great company, and good vibes.

------------------------------------------------------------------------------------

Copyright 12/29/2005 Justin Coslor

Sayings

Design a series of philosophical postcards and T-Shirts with powerful true messages on them that shift people's paradigms.

Examples:

- - - - - - - - - - - - - - - -

Never treat anyone badly whatsoever, because if everyone does that it's Utopia.

Always treat everyone well.

Be gentle and careful and polite.

Be humble and compassionate, and be honest and natural.

Think metaphorically.

Bring about happiness and harmony.

Realize and discover Universal hope and understanding.

Truth is contextual; upgrade your ethics infinitely.

Plant a garden. Protect a forest.

Link foundations.

Build networks of questions.

Map out positive long-term thinking possibilities.

There are always good possibilities for everyone.

Information is a symphony of symbolism and symmetry.

Knowledge as patterns in contexts.

Thinking as storing and networking knowledge.

Neurons that fire together wire together.

Symbiosis = Mutually Beneficial Fair Collaboration

All reactions (thoughts, emotions, and actions) come from expectations.

Expectations are equivalent to beliefs.

All mistakes and negativity comes from short-term thinking.

------------------------------------------------------------------------------------

http://frdcsa.org/~justin/writing3
http://frdcsa.org/~justin/draft

p.

The Inner Outer Pyramidal Prime Pattern
by Justin Coslor

Imagine these centered like a triangle with
symmetrical right and left sides.

                              [i] 1 i
                              oo 2 o
                            o[i]o 3 i
                          oo[i]oo 5 o
                    oo[i][i][i]oo 7 i
                oooo[i][i][i]oooo 11 o
          oooo[i][i][i][i][i]oooo 13 i
      oooooo[i][i][i][i][i]oooooo 17 o
oooooo[i][i][i][i][i][i][i]oooooo 19 i

See how the symmetry rotates back and forth between
adding more blocks symmetrically to the inside, and
then symmetrically to the outside, then inside,
outside, . . . etc.

Imagine four of these triangles made into a pyramid.
That is what I call "The Inner Outer Pyramidal Prime Pattern".
It can be abbreviated "IOPPP".

It's easier to visualize when all of the blocks in the pyramid
are the same size. It's what I call "Pyramidal Expansion".

Then the prime numbers can be able to be predicted in general by
calculating positions on the slope of the edge of the pyramid in
terms of a 3D (x,y,z) coordinate.