my_text_data/writings/universal_conlang.txt

WORK IN PROGRESS, BRAIN DUMP OF CONCEPTS

================================ NEW ATTEMPT ===================================

=== CONCEPT OF A UNIVERSAL CONLANG ===

This is an attempt at coming up with a way of how to create a constructed
language for communication of living beings that are possibly not only humans
but perhaps aliens quite different from us, a language whose definition is
firm and stays unchanged over ages -- something that's very hard or even
seeming impossible due to fuzziness and only intutive/learned semantics of any
traditional language. The most difficult question is how to define semantics
of terms such as "though", "life", "to be", "to exist", "consider"... even
relatively simple words like "dog" are hard to capture, defining the word by
translation from another language will tie the definition to another language
that's changing, using a picture is unclear -- a picture of a dog doesn't say
if we mean just the specific dog in the picture, any animal similar to the one
in the picture (and HOW similar?), dog as a species (what does species even
mean) etc.

This is more of a recorded thought process than an attempt at creating a real
language, the purpose is to explore the WAY in which such a language could
eventually be made.

Let's divide the process in these phases:

1. FOUNDATIONS: Defining the underlying principles on which the language is
   built, such as the model of a world it considers etc. For now we may do this
   in our current language, English and math.
2. ABSTRACT LANGUAGE: Here we build a language based on the principles, i.e. we
   define specific words and their meanings so that they can already form
   structures usable for communcation. However we still do this in a way that's
   abstract, i.e. still using some intermeniate notation, for example English
   and math. After this step we will have meanings of words but not the actual
   words.
3. SPECIFIC LANGUAGE: Here we take the abstract definition and turn it to a
   concrete language, i.e. one with its own sounds (or similar physical ways of
   communication), possibly something like a writing system etc. Of course we
   may create several languages from the same abstract language if we want.

1. FOUNDATIONS:

The basic idea:
  1. We create a model of simple mathematical world -- here we choose a 3D grid
     of discrete values in which cells can talk (emit strings of language).
  2. We create a function that takes a talking cell on its input and decides
     (returns true or false) if the language is used correctly or not. By this
     we separate instances of the model in which cells use the language
     correctly and those where they don't. By examining the function one can
     deduce the correct use of the language, meaning of each word in context of
     the mathematical world.
  3. If we now find a correspondence between our abstract model and real world
     (e.g. cells = beings, Z-axis = time, ...), we can use the language in the
     real world too.

For example: if a cell is emitting a sentence that's a question, the verifying
function will check if at the time of this there is any living cell (what's
living will be further defined in the language) nearby to hear the question,
as asking a question without anyone around is incorrect use of the language.
Similarly if a cell is emitting an answer, there must have been another cell
emitting a question nearby in the previous moment, otherwise the language is
used incorrectly. By this we can precisely convey what it means to ask and
answer. And so on.

The world: we consider a world to be an arbitrarily large three dimensional grid
of discrete values (e.g. natural numbers, but without ordering etc.). We will
see X and Y dimensions as spatial, Z as temporal. Furthermore each cell (any
[X,Y,Z] coordinate) MAY (or may not) be emitting a string, meaning it is
communicating.

TODO

2. ABSTRACT LANGUAGE:

is_correct(SENTENCE, X, Y, Z): // the main function

  if (not(is_individual(world[X,Y,Z]))) // non-individuals (e.g. walls) mustn't talk
    return false

  TODO


is_individual(TYPE): // kind of "living being"
  TODO: continuously exists in time in exactly one instance, i.e. there is
  exactly only one instance of this cell at any time, except for before its
  birth and after its death, when there are zero


TODO


================================ OLD ATTEMPT ===================================

=== CONCEPT OF A UNIVERSAL CONLANG ===

This is an attempt at coming up with a way of how to create a constructed
language for communication of living beings that are possibly not only humans
but perhaps aliens quite different from us, a language whose definition is
firm and stays unchanged over ages -- something that's very hard or even
seeming impossible due to fuzziness and only intutive/learned semantics of any
traditional language. The most difficult question is how to define semantics
of terms such as "though", "life", "to be", "to exist", "consider"... even
relatively simple words like "dog" are hard to capture, defining the word by
translation from another language will tie the definition to another language
that's changing, using a picture is unclear -- a picture of a dog doesn't say
if we mean just the specific dog in the picture, any animal similar to the one
in the picture (and HOW similar?), dog as a species (what does species even
mean) etc.

This is more of a recorded thought process than an attempt at creating a real
language, the purpose is to explore the WAY in which such a language could
eventually be made.

Let's divide the process in these phases:

1. FOUNDATIONS: Defining the underlying principles on which the
  language is built, such as the model of a world it considers etc. For now we
  may do this in our current language, English and math.
2. ABSTRACT LANGUAGE: Here we build a language based on the
  principles, i.e. we define specific words and their meanings so that they
  can already form structures usable for communcation. However we still do this
  in a way that's abstract, i.e. still using some intermeniate notation, for
  example English and math. After this step we will have meanings of words but
  not the actual words.
3. SPECIFIC LANGUAGE: Here we take the abstract definition and
  turn it to a concrete language, i.e. one with its own sounds (or similar
  physical ways of communication), possibly something like a writing system
  etc. Of course we may create several languages from the same abstract language
  if we want.

=== 1: FOUNDATIONS

The basic idea of how to create firmly defined semantics is this: create a
formal mathematical model of a world -- in this case a very simple one -- then
create a language for this world. If we then find correspondence between our
physical reality and our abstract mathematical world, we can use the language
we have created also for our physical reality. The aliens can do the same as
long as they find correspondences between the "toy universe" and their universe.

THE WORLD: for simplicity we will consider a world to be an infinite 3D grid,
an infinite three dimensional "array" of natural numbers.

Note: two dimensions (X and Y) will be seen as spatial and one (Z) being seen
as temporal (representing time). The fact one dimension represents time is not
inherently part of the world's definition, but we will later try to view the
world as if it is, so we mention it here just to help us form the correspondence
of the world model to our physical reality. Similarly the natural number 0 is
seen as "void", "non presence". Other such concepts will emerge as we'll be
defining actual patterns.

PATTERN: pattern is a computable set (potentially infinite) of FINITE 3D grids
of natural numbers, i.e. we may imagine it as a function that takes any
subspace (MxNxO sized, if any M, N and/or O is zero, all sizes are taken to
be zero) of the world and outputs TRUE or FALSE, saying whether
the pattern is present or not. Initial, most essential patterns may be defined
mathematically, e.g. in a programming language, further patterns should be
defined by using already defined patterns so as to make the language as much
as possible "self-hosted", "self-contained".

PATTERN GENERATORS: can be seen as a way to automatically make new patterns from
already existing patterns, e.g. a NOT operator automatically
makes a negation of any pattern -- if we have pattern X, NOT(X) is exactly every
pattern that is not X.

=== 2: ABSTRACT LANGUAGE

TODO: show it's turing complete

TODO:
- patterns to make:
  - "void"/"empty": any subspace that's solely composed of 0s
  - "walk": 
  - numbers: infinitely many patterns, each one representing a number and
    matching subspaces that contain that many non-zero cells
  - kind numbers: same as numbers but count how many distinct numbers there
    exist in the subspace
- pattern operators:
  - "then": takes patterns X and Y, matches if the subspace can be split in
    the temporal dimension so that lower part matches X and upper part mathes Y

pattern generators:
  NOT(P): matches exactly every pattern that doesn't match P
  AND(P1,P2): matches any pattern that simultaneously matches P1 and P2
  OR(P1,P2): matches any pattern that matches P1, P2 or both
  THEN(P1,P2): matches any pattern that can be split in the Z direction so that
    the bottom one (under this Z) matches P1 and the upper one matches P2
  REVERSE(P): matches any pattern that if flipped vertically (in Z direction)
    matches P
  ISOLATE_N1_N2_N3_...(P): matches any pattern that if all cells not being
    N1, N2, N3, ... are replaced with zero, matches P

  EACH_MOMENT(P): matches any pattern which if slices into individual Z
    "moments", each one matches P

  todo: more

pattern definitions:

  NOTHING: matches only empty pattern (0x0x0)
  VOID: pattern that doesn't have cells > zero, i.e. even NOTHING
  MOMENT: any pattern that has Z size of 1


  NUMBER_0: VOID
  
  numbers: WIP, ideas:
    - maybe make patterns like COUNT_TYPES_N, COUNT_CELLS_N, COUNT_TIME_N etc.,
      matching patterns with N distinct type of cells, N cells total, N size
      in Z direction respectively etc.
    - then make general patterns NUMBER_N, each of which is OR of all the above,
      i.e. generalized the concept of a number to match any pattern where number
      N is present in any form (be it number of cells, numbers of cell types,
      size of the pattern itself etc.)?

  EMERGENCE: THEN(VOID,NOT(VOID))
  DISAPPEARANCE: REVERSE(EMERGENCE)
  MOVEMENT: todo, idea: there have to be cells moving over time, e.g. in
    4 neighbourhood
  MOVEMENT8: todo, like MOVEMENT but with 8 neighbourhood?
  SLOW_MOVEMENT: todo, like movement but limit the speed
  STILLNESS: NOT(MOVEMENT)
  KILL: todo, idea: cell close to another makes another disappear
  GROWTH: todo, idea: cells create cells of same type in their neighbourhood
  REPRODUCTION: todo, idea: cell spawns a cell of the same type in its
    neighbourhood
  CHASE: todo
  CENTER: todo, has non-zero exactly on center cell?
  EAST, WEST, NORTH, SOUTH: todo, idea: match only if there is something in
    corresponding half of the pattern

  LIFE: todo, this will be hard :)

  potentially very hard:
    SADNESS, HAPPINESS, THOUGHT, LOVE, HATE etc.

  todo: more

=== 3: SPECIFIC LANGUAGE

TODO