neuLinge Genesis

GENESIS 1 - In the Beginning

1.1 Before the Beginning
1.2 History of this project
1.3 How robots would like humans to talk to them
1.4 A-priori-, Meta-, and User-Levels: protoLinga, protoNeuLinge, and neuLingeApp
1.5 The Descent

GENESIS 2 - The Unfolding

2.1 This Document as neuLinge source code
2.2 Interpreter Vs Compiler and the question of Instant Actuation
2.3 Bootstrap
2.4 Incarnation

GENESIS 3 - First creatures

3.1 Basic structure of phrases
3.2 Logical Operators
3.3 Functionality (Examples)

GENESIS 4 - First Relations

4.1 The ogre IS
4.2 Scales
4.3 Mathematical equations

Appendix - The n-Commandments (n=9, currently)

A.1 The paradox of bypassing Creation
A.2 The n-Commandments in detail
A.2.1 (C1) Thou shalt not make unto thee any identification
A.2.2 (C2) Thou shalt not use two words for the same thing
A.2.3 (C3) Thou shalt not use the same word for two different things
A.2.4 (C4) Thou shalt not confuse operation with function
A.2.5 (C5) Thou shalt not redefine existing meta-symbols
A.2.6 (C6) Thou shalt not speak using undefined words
A.2.7 (C7) Thou shalt take a white-space as a separator
A.2.8 (C8) Thou shalt take not create a token for something that is undefinable
A.2.9 (C9) Thou shalt take not mistake a function for an operation
(is this all?)


GENESIS 1

1.1 Before the Beginning

The neuLinge project, the vision, projection, and creation of a new human language which is 100% computer-compatible, has many profound and perhaps unexpected aspects and implications. One of them, and perhaps the most controversious, is the necessary contemplation on how a language is created at all, how it evolves, if at all, and why it changes over time, which is certainly does. These contemplations are inevitable if we strive for avoiding the pitfalls and traps of our modern languages. If the latter would not exist, we would not need a new language at all: why fix it if it ain't broken? We are forced to have a new look at our current languages in use and will have to admit its inadequacies.

It becomes unavoidable to confront the enigma of a creator or a creating principle even if we would call it an 'evolution' as a metaphor. This discourse does not try to make a proof of whatever philosophy. However, we will point throughout the document to the most comprehensive and systematic integration of language, mathematics and philosophy to date, the Tractatus Logico-Philosophicus of Wittgenstein, translated by the author of the document, and italicized, when quoted, throughout this document.

We apparently cannot create a language without having a conceptual framework that describes it basic elements. These elements form an axiomatic system, a minimal set of a-priori assumption which will allow us to define a language by itself.

From a viewpoint of 'Systems Theory', those concepts come from 'outside' the system, and, as such, cannot be decided upon from WITHIN the system. As an immediate result of this contemplation, we can neither affirm the existence of a creator nor can we affirm its non-existence. The discussion of 'God' in this context is moot and does not bring any result. "Of what one cannot talk about, one must be silent".[W:7]

1.2 History of this project

This project began with a casual ramark of Niklaus Wirth, the creator of Pascal, Modula-2, and various other computer languages. He asked, sometime in spring of the year 1977, if we can know just "How robots would like humans to talk to them"? One would be inclined to think that that's what we assume when we create computer languages, but, if we look closely, we were always asking "how can we make a computer understand us?" and the difference is subtle but substantial. A few years later the author of these lines wrote a diploma thesis on a freely defineable parser. A parser is a program fragments that analysis a stream of incoming communication particles, usually from human sources, and isolates its components, called 'tokens', before it hands it over to a compiler which creates the final computer program to be executed. If it is freely programmable it can be called a 'meta-parser', and it means that it is not limited to a single language. Similarly, a 'compiler' which creates the resulting code based on a freely defineably language, is called a 'compiler-compiler.

In those times it became very clear that we don't simply are confronted with a technical challenge, but with a deeply philosophical one, and that we have to use existing language wisely in order to define a new one. We have to reflect about the differences of Wittgenstein's 'symbol', 'Satz' (phrase), 'Zeichen' (sign)), and 'Urzeichen' (proto-sign). [W:3.317,5.45] As incredible as it sounds, we are prompted to link to a contemplation of life itself: "Describing the character of a 'phrase' means to describe the character of all description, meaning the character of the world". [W:5.4711]

1.3 How robots would like humans to talk to them

A computer's mind doesn't mind what language you are approaching it with. It can store the words and syntax of billions of languages on a single harddrive. If a language has a billion words or just ten or twelve, it doesn't mind. But if one of those has two meanings, it goes crazy. And if your shopping list has 3 items or ten thousand, it couldn't care less. It gets confused, however, if you don't say when your shopping lists is ending. The computer's mind makes a big difference between different kinds of 'and' and 'or', human language doesn't. And, to crown this short list of irreparable shortcomings of the human languages, many 'natural' languages use the verb 'to be', and excessively so. And this is a verb which is, not just for a computer, not just superfluos but outright dangerous. For the computer's mind, a tree can never 'be' green, what is may have are green leaves, but that's quite a different thing. [W:3.323]

1.4 A-priori-, Meta-, and User-Levels: protoLinga, protoNeuLinge, and neuLingeApp

We will start by detailing the difference between the 'meta-concept/a-priori' level and 'platonic' levels. We shall call the 'meta-concept level' protoLinga and not argue whence it came. A 'meta-concept' in the sense being used here, and therefore protoLinga itself, does not exist. However, a 'platonic ideal' does exist as a Meme in the consciousness of thinking Beings. For example, the meta-concept of a 'screw' would be a cylinder with spiral engravings. A blueprint or drawing could be its form for an 'incarnation'. This would still be a 'perfect' screw, a 'platonic idea'. It exists ever since its 'invention' in the mind of man in the modern world. Note, that the meta-concept existed all along; only with the invention of the screw, it 'incarnated' into the consciousness of man.

We can now descend further into the 'caves' of the physical Universe. From the initial platonic level, a mere idea of it in the mind of a person, it can be communicated via human language, a physical drawing, or an electronic pattern in the form of a computer program or definition scheme, such as SDL, a Schema Definition Language based on XML.

From there it can descend further as a prototype, perhaps in clay or carved in wood. Further down, provided we have the tools, we can create the first version of it in metal, a prototype, and finally, it could be mass-produced as 'clones' or 'replicates'.

Note, that the passage from a description of a 'thing' to a 'real thing' with physical properties is a monumental step. And note also, that with the 'physical incarnation' as a 'real thing', it lost its purity: it is now spoiled with an *error* because no matter how accurate its fabrication has been, the 'resolution' of the physical Universe does not allow for its immaculate birth.

Not only purity is lost by the descend from the template to the caves, but also eternity. Once 'incarnated', the wonderful idea of a screw has become a tale of a mortal, from birth at the factory, to it being thrown into the trash or recycled.

Thus we rediscover the two cardinal problems of life itself: mortality and faultiness, two aspects not commonly considered in natural human languages as structural requirements of scope and tolerance, but left to the ambiguities of human communication, a fact not acceptable by a computer's mind.

1.5 The Descent

Along with the descent into 'the caves' of the real world, we witness an increase in the limits of its self-definition. From a state of unlimited possibilites outside of all systems, with every step of definition we lose liberties of self-definition even if we can redefine to a certain degree and we can create sub-systems. From the Architect (A Level) who determines the overall structure of the language, we arrive at the Engineer (B Level) who is defining the actual whereabouts of the language. The basic language at hand is well-defined at this level. An Administrator (C Level) understands the overall concept so well that he can make certain adjustments without compromising the system itself, such as defining slangs and nicknames, even shortcuts within certain limits, all of which amounts to a partial redefinition of some aspects of the language. At the bottom are human, robotic, and phantom users (D, E, F). The latter is a catch-all for system-internal processes, like remote or virtual agents, and, in the worst case, viruses.

Chart of Descent from concept to manifestation

GENESIS 2

The Unfolding

2.1 This Document as neuLinge source code

One interesting, unexpected aspect of a self-defining language is that it cannot have 'comments' such as we find in programming languages. Its definition is its own language. To have comments, we would need to spawn a concurrent process. In this document, we will encapsulate neuLinge (all levels of it) by the use of HTML H4 headers. After being filtered, that what was sieved is now pure neuLinge and could be input to any compiler-compiler compatible with the meta-definitions described below.

2.2 Interpreter Vs Compiler and the question of Instant Actuation

We want to point to a question which is more fundamental than often assumed: the controversy between interpreter and compiler. An interpreter is taken one statement of a time and is often thought as 'crude' in comparison to a compiler which is a program that takes a chunk of statements and creates a packet of directly executable code. We will not take sides here, but we need to point out that a self-defining language cannot have 'phases' or 'layers' of existence. It must dynamically go from nothing to everything, and seamlessly so. It cannot have therefore anything else than the bahavior of what we call an interpreter.

For our purposes, we need to be even more radical. In 'real life', we cannot wait until an 'end of the line' is encountered, and a language that aims to connect human and robotic worlds must accommodate this. If that it so, the neuLinge project implies the use of the sacred cow of 'self-modifying' code. Even 'worse', of 'self-modifying syntax'. It absolutely relies on the 'instant actuation' of commands. Again. with this we mean that we do NOT wait until the end of a typical 'command line' until the code is executed. In the contrary, upon encountering a token, if something can be executed, it WILL BE executed.

As mentioned, in the past this behavior was seen as primitive or non-intelligent. If we have an honest look at natural languages, we will see however, that this is invariably true for all of them.

2.3 Bootstrap

Finally, we will start defining a language from scratch.

As noted above, this implies the paradoxical situation that we do not yet have a language to start describing the language. We introduce the idea of abstract 'concepts' which are formed in an arbitrary way because they do NOT exist as such. We will call this 'bootstrapping' and we will use it only once. "(He must throw away the ladder after having stepped up on it). He must overcome these phrases, then he will see the world correctly."[W:6.54]

Before beginning to define the manifesting language, we create or decide upon an initial notational form. This notation of the elements of the initial notation could be of any manifestable form, for example:

- words formed from standard Western letters
- hieroglyphs,
- Chinese Kanji,
- Martian cuneiform,
- plain sound structures.

The notational form is linking our new language with the world. "The gramophone-disk, the musical thought, the musical notation, the sound waves - all of them are in that depicting, internal relationship which exists between language and world."[W:4.014]

Here and now, 'before the beginning', we will select "US-ASCII" as an a-priori set of letters which can be itself or token (language elements) or form tokens through the process of concatenation.

We call the concept protoLinga, the mother of all languages, and its children to be of the meta-type protoLingaConcept

and its firstborn:

protoLingaSeparator: which lives only to define a token to separate future tokens.

With this we are ready to kickstart the process.

protoLingaSeparator[space]

It is quite peculiar that in language self-creation, its first word is a SEPARATOR. Therefore, we may say, in the beginning was the separator: the first token encountered will be the separator token, in this case a [space]. For some languages a period [.] may have been more appropriate. For spoken languages, like all of the human 'natural' languages, the separator is a pause in speaking. That means, that in all of those cases, its life began with a [silence].

It becomes clear at this point that a bootstrapping process assumes 'instant actuation'. This means, everything is executed instantaneously, similar, it may seem, to an Interpreter (see discussion above). Thus, no end token is required.

2.4 Incarnation Now we will 'incarnate' the basic ('axiomatic') words to increase readability throughout the rest of the definitions:

To this end we need to 'import' the words that are used to be as tokens from. To never endanger the goal of failsafety of neuLinge, everything foreign to it, must be 'encapsulated', or, in other words, be in quarantine until accepted.

protoLingaBeginEncapsulated: beginning an encapsulation of a word initially foreign to the new language
protoLingaEndEncapsulated: ending an encapsulation

We also need beginning and end of definitions as meta-concepts:

protoLingaDefineOpen: beginning of a definition
protoLingaDefineClose: closing of a definition

protoLingaDefineOpen protoLingaBeginEncapsulated "en" protoLingaEndEncapsulated protoLingaDefineClose

We called the beginning of encapsulation "en"; now let's use it right away to name the ending:

protoLingaDefineOpen protoLingaEndEncapsulated en "ne" protoLingaEndEncapsulated protoLingaDefineClose

We can now more easily redefine the other tokens (words) needed for the definition of the language (the default names for the syntax elements of neuLinge. Note again, that this will not affect the user who usually never encounters the actual syntax definitions.:

we can define:
protoLingaDefineOpen protoLingaDefineOpen en "def" ne protoLingaDefineEnd
def protoLingaDefineEnd en "fed" ne protoLingaDefineEnd


Note: we re-encounter an interesting topic here: is a redefinition already valid for the rest of the definition itself?
This is non-trivial problem for some process application. For bootstrapping, we cannot assume anything and must exclude restrictions.

We could therefore state the above naming act as well as:

def protoLingaDefineEnd en "fed" ne fed

(The above line is not in italic to not confuse the text of the complete bootstrapping document.)

We can now easily redefine the ConceptWorte to increase the readability of the rest of the definition process and we start by giving the new language a name, for simplicity "neuLinge" but it could be anything:

protoLingaDefineEigen: points to itself; warning: circular!

def protoLingaEigen en "neuLinge" ne fed

Continuing the process:

protoLingaListOpen: opening a list
protoLingaListClose: closes a list

def protoLingaListOpen en "li" ne fed

def protoLingaListClosen en "il" ne fed

def protoLingaAllOverNow en "fine" ne fed

def protoLingaStatement en "frase" ne fed

def neuLinge li frase il e fine fed

Defines the basic sequence of a session. A list with a single element has no restrictions and can therefore be repetitive.

GENESIS 3

3.1 Basic structure of phrases

After bootstrapping the core definition we begin with the definition of the distinct features of this incarnation of a neuLinge language

First, we will incarnate the concepts of an 'atom' as a basic element We could introduce an enumeration seperator but we can also imply that any suffix '-e' to a 'root' word serves as such as a seperator. We will sacrifice in this incarnation redundancy for the sake of easier pronounciation. It does not matter what we define first because we will use the complete structure only after the languages has been defined completely.

def protoLingaAtom en "atome" ne fed

def protoLingaSource en "fonte" ne fed

def protoLingaSink en "sinke" ne fed

def protoLingaMethod en "metode" ne fed

Logical Operators

We will also need to incarnate the first of several logical operators. We do not need to worry about mathematical operators because anything that can be defined by algorithms can be defined after the language proper.

def protoLingaSetUnion "unione" ne fed

def frase li mode e fonte e sinke e metode il unione fed

Defines this neuLinge incarnation to mandatorily consist of five elements: mode, scope, source, sink, and method which form a basic transaction model.

With this, we made a giant step. We have created the paradigm which the new language will follow. In the following we would create the functionality of the language.

Functionality (Examples)

Some examples are in order. For a robot with a predefined inventory and map, such as for warehouse store and retrieval applications, all we need are COMMANDS. For applications that are concerned only with definitions and have predefined object descriptions, we would not need a COMMAND, and, well designed, not even DECISION or a QUERY. However, if we want to create a language capable of 'assessment' and 'reporting' capabilites, we need to include DECISION ability. Lastly for interactive applications, we would need to add also a QUERY mode.

At this point, we need to advise that "operation and function must not be mistaken with each other". [W:5.25] Without such a clear distinction, we would fall easily back into the errors made in the past while designing new features.

The above suffices to create a new language paradigm and to understand the documentation of a neuLinge language, such as the complete definition of neuLingeGenere, a general purpose language designed to be an easy to learn universal language.

GENESIS 4 - First Relations

The ogre IS

We will start with what we DO NOT want in any new language, and this is the word 'is'. As already mentioned, it is not only utterly and completely disnecessary and unqualified for relations between symbols and/or manifestations, it is utterly misleading. "So arise easily the most fundamental mix-ups (of which the entire philosophy is full of it).".[W:6.2322]

As representating the identity between two expressions in general, we can further quote Wittgenstein "The identity of the meaning between two expressions cannot be claimed. In order to be able to claim something about its meaning, I must know its meaning: and, knowing its meaning, I know whether they mean the same of something different.".[W:6.2322] This goes in line, of course, with Korzybski's General Semantics.

As an interesting problem, we see here the impossibility of preventing a re-introduction of the identity-concept further down the line of language creation while still being at the A- or B-levels (language architects and engineers). A negative rule (like 'do not use identities') can neither be created nor excluded within the language itself. Such a 'law' would have to exist in parallel to the language and this would be truly a paradox. This paradox has been, of course, being heavily used in main-stream religions.

4.2 Scales

In order to show how to incorporate variety of functionality of the language, we will now demonstrate how to CREATE elements into a new language. A systematic definition of a complete language may not necessarily follow this route, we choose the latter here for didactic purposes.

One of the most fundamental observation in the world is the existence of 'scales' as gradients between extremes. The definitions:

def protoLingaScale "skale" ne fed

def protoLingaTop "obe" ne fed

def protoLingaBottom "une" ne fed

def protoLingaDegree "grade" ne fed

...map the concept of a scale from a meta-concept and defines tokens for 'upper' (obe), 'lower', and 'gradient scaling (grade).

Do we have aleady enough defined to be able to construct any and all thinkable languages?


Appendix - The n-Commands (currently, n=9)

The paradox of bypassing Creation

To our surprise, we found a set of premises which were not possible to imply in the meta-language definition. We must therefore, on our mission to create the perfect language through itself, take recourse to a measure we absolutely tried to avoid: a separate definition of what NOT to do. This paradox of the need of bypassing the auto-definition of our meta-language is philosophically significant.

We tentatively, for lack of a better procedure, are also including one non-negating commandment, namely the first act of creation itself, the definition of a 'separator between tokens' which we will call here a 'white-space'. It is the link between the Creator level and all 'lower' levels of auto-definition.

A.2 The n-Commandments in detail

A.2.1 (C1) Thou shalt not make unto thee any identification
A.2.2 (C2) Thou shalt not use two words for the same thing
A.2.3 (C3) Thou shalt not use the same word for two different things
A.2.4 (C4) Thou shalt not confuse operation with function
A.2.5 (C5) Thou shalt not redefine existing meta-symbols
A.2.6 (C6) Thou shalt not speak using undefined words
A.2.7 (C7) Thou shalt take a white-space as a separator
A.2.8 (C8) Thou shalt take not create a token for something that is undefinable
A.2.9 (C9) Thou shalt take not mistake a function for an operation