CHAPTER 1 — The Basic Signs
*Iconic Representation + Function + Role in the System*
The four central signs are not letters, not words — they are spaces, not places.
1.1 𒈾 — Area / Decision Module
Sign: 𒈾
Iconic Form:
- small wedge left → start + retroactive boundary
- main body → defined area
- slight opening → entry point
System Function:
An area in which decisions are made. Not a place, but a functional module.
Role in the Process Model:
- marks the start of an area
- defines boundaries
- contains operators (EN, LUGAL, SIPA …)
Example:
𒂗𒈨𒉡 𒈾 𒀭𒈗 (En‑men‑dur‑ana)
1.2 𒆠 — KI — Process Field / Functional Field
Sign: 𒆠
Iconic Form:
- horizontal and vertical lines → parcel structure
- looks like a cultivated field (iconically correct)
- open structure → not closed
System Function:
An open process space in which operations are carried out. Not a physical field, but a functional field.
Role in the Process Model:
- execution surface
- location of process steps
- can contain multiple operators
Example:
In early administrative lists as a functional field.
1.3 𒌷 — URU — Core Space / Closed Functional Area
Sign: 𒌷
Iconic Form:
- rectangular blocks → closed space
- small opening bottom left → access / weak point
- inner structure → core module
System Function:
A closed functional area. Later interpreted as "city" but corresponds more to a fortress with a seemingly weak, narrowing entrance and a heavily fortified interior — originally, however, a core space.
Role in the Process Model:
- closed modules
- stable functional cores
- no open processes
Example:
𒌷𒀀𒆠 (URU‑A‑KI)
1.4 𒀭 — AN — Meta Level / Upper Space
Sign: 𒀭
Iconic Form:
- superordinate structure
- symmetrically read: "stable"
- closed (coherence / simplified sphere or axis)
- acts like a top layer or a simplified sphere / axis
- iconically: space, not movement
System Function:
The meta level of a system. Not the sky, but a superordinate context. AN is the meta space that lies above all areas.
Role in the Process Model:
- meta module
- context provider
- superordinate instance
- upper space
Example:
𒀭𒈗 (AN + A) → meta execution
1.4b 𒀭 — DINGIR — Activation Marker / Meta Flag
Sign: 𒀭 (same sign, different function)
Iconic Form:
- same basic form
- but read dynamically
- wedges are slightly offset → generate rotation / activation
- iconically: impulse, not space
System Function:
DINGIR is not a god, but an activation marker:
"This module is active, prioritized or meta-effective."
Role:
- function prefix
- activation
- prioritization
- meta flag
The Functional Difference:
| AN | = space (static) |
| DINGIR | = activation (dynamic) |
The difference does not arise in the sign, but in:
- position
- combination
- syntactic role
This is iconic multiple coding.
1.5 𒈬 — MU — Cycle / Moon Cycle
Sign: 𒈬
Iconic Form:
- curved form
- cyclical
- recurring
System Function:
A cycle, originally a moon cycle. In the King List: duration of a process module.
Role in the Process Model:
- cycle duration
- repetition interval
- runtime
Example:
"𒈬 1200" → 1200 cycles
1.6 𒌓 — UD — Cycle End / Completion
Sign: 𒌓
Iconic Form:
- horizontal line → completion
- ray form → endpoint
- clear boundary
System Function:
The end of a cycle. Not "day", but completion marker.
Role in the Process Model:
- cycle end
- completion of an area
- transition to AŠ (restart)
Example:
MU → UD → AŠ
---
1.7 𒀸 — AŠ — Restart / Re-Initialization
Sign: 𒀸
Iconic Form:
- diagonal wedges → realignment
- opening → starting point
- transition form
System Function:
A restart. Not a "sacrifice", not a "flood", but a reset.
Role in the Process Model:
- re-initialization
- start of a new cycle
- system reset
Example:
Translation: After the „flood" is now a simple reset and no flood: 𒀸
1.8 𒈗 — A — Execution / Process Flow
Sign: 𒈗
Iconic Form (complete):
- four layered wedges left → multiple decision-makers / inputs
- long wedge → decision level
- small wedge right → start impulse
- slightly shorter wedge downward → start completed
- angled wedges → process phases
- three small wedges → intermediate goals / milestones
- converging wedges → completion / goal
System Function:
A complete flowchart in one sign.
Role in the Process Model:
- execution
- process flow
- implementation
- completion
Example:
𒀭𒈗 (AN + A) → meta execution
CHAPTER 2 — The Iconic Grammar of Sumerian Signs
How the signs are combined to map processes
The Sumerians had no grammar in the linguistic sense. Their "grammar" was iconic, geometric, processual.
It consisted of:
- start forms
- boundary forms
- area forms
- operator positions
- cycle markings
- reset mechanics
- meta flags (DINGIR)
2.1 Start Wedge — 𒁹 — Beginning of a Module
Sign: 𒁹
Function:
Marks the beginning of an area, process or module.
Rule:
When 𒁹 precedes a sign → the following sign is initialized.
Example:
𒁹𒈾 → area is opened.
2.2 Boundary Wedge — 𒄑 — Boundary / Retroaction
Sign: 𒄑
Function:
Marks a boundary, often retroactive.
Rule:
When 𒄑 stands left → boundary acts to the right.
When 𒄑 stands right → boundary acts to the left.
Example:
𒄑𒆠 → bounded field.
2.3 Area Opening — 𒈾 — Start of a Decision Space
Sign: 𒈾
Rule:
When 𒈾 appears → an area begins that:
- contains operators
- makes decisions
- has its own context
Example:
𒈾𒀭𒈗 → area + meta execution.
2.4 Area Closing — (no separate sign, but combination)
The Sumerians had no explicit closing sign. Instead, an area is closed by:
- UD (𒌓) → completion
- AŠ (𒀸) → reset
- or by change of module type
Rule:
An area ends when:
- a cycle ends (𒌓)
- a reset occurs (𒀸)
- a new area sign begins (𒈾)
2.5 Operator Position — EN, LUGAL, SIPA, LU, etc.
Operators always stand within an area.
Rule:
- operators never stand alone
- they are always embedded in 𒈾 or 𒆠
- they define the function of the area
Example:
𒈾𒂗𒈗 → area + EN + execution.
2.6 Process Flow — 𒈗 — Execution
Sign: 𒈗
Rule:
When 𒈗 appears → a process is executed.
When 𒈗 stands at the end → the process is completed.
When 𒈗 follows 𒀭 → meta execution.
2.7 Cycle Marking — 𒈬 (MU) → 𒌓 (UD)
Rule:
MU = duration
UD = completion
Example:
𒈬 1200 𒌓 = 1200 cycles completed.
2.8 Reset Mechanic — 𒀸 (AŠ)
Rule:
When 𒀸 appears → a new cycle begins.
Example:
𒌓 → 𒀸
Completion → Restart.
2.9 Meta Flag — 𒀭 (DINGIR)
Rule:
When 𒀭 precedes a sign → the following sign is activated / prioritized / meta-effective.
When 𒀭 stands alone → it is AN, the meta space.
Examples:
- 𒀭𒈗 → meta execution
- 𒀭𒂗 → activated operator
- 𒀭 alone → AN (meta space)
2.10 Combination Rules (the actual grammar)
Rule 1: Area → Operator → Process → Cycle → Completion
𒈾 → EN → 𒈗 → 𒈬 → 𒌓
Rule 2: Meta flag raises a module to a higher level
𒀭 + X = X on meta level
Rule 3: Reset resets everything
𒀸 = Restart
Rule 4: Fields (𒆠) are open, core spaces (𒌷) are closed
Rule 5: Signs are not words, but modules
CHAPTER 3 — The Four Levels of System Architecture
How the Sumerians organized their world into functional layers
The Sumerian script does not map a language, but a multi-layered process model. Every sign belongs to a level, and every level has a clear system function.
We define the four levels:
1. Meta Level (AN)
2. Area Level (𒈾)
3. Field Level (𒆠)
4. Core Space Level (𒌷)
These four levels are not metaphorical, but iconically embedded in the sign itself.
3.1 Meta Level — 𒀭 (AN)
Level 1 — The Upper Space
Sign: 𒀭
Function:
The superordinate context in which processes take place. AN is not the sky, but a meta module.
Properties:
- symmetrically read → stable
- closed → coherent
- iconically: sphere / axis / upper space
Role in the System:
- defines framework conditions
- contains no processes
- contains no operators
- is not itself active (only DINGIR activates)
Example:
𒀭𒈗 → execution on meta level
**Translation approach:**
"Meta level", "upper space", "context layer".
3.2 Area Level — 𒈾 (NA)
*Level 2 — Decision Spaces*
Sign: 𒈾
Function:
An area in which decisions are made. Operators such as EN, LUGAL, SIPA operate here.
Properties:
- small wedge left → start + boundary
- main body → defined space
- opening → entry point
Role in the System:
- contains operators
- defines functional modules
- is the "workspace" of the operators
Example:
𒈾𒂗𒈗 → area + EN + execution
Translation approach:
"Area", "module", "decision space".
3.3 Field Level — 𒆠 (KI)
Level 3 — Open Process Spaces
Sign: 𒆠
Function:
An open process space in which operations take place.
Properties:
- parceled
- open
- segmented
- iconically: field / surface
Role in the System:
- execution surface
- location of process steps
- can contain multiple operators
Example:
𒆠𒈗 → process in the field
Translation approach:
"Field", "process surface", "functional field".
3.4 Core Space Level — 𒌷 (URU)
Level 4 — Closed Functional Cores
Sign: 𒌷
Function:
A closed functional area. Later misinterpreted as "city".
Properties:
- rectangular block
- small opening → access
- inner structure → core module
- iconically: container / core space
Role in the System:
- stable modules
- no open processes
- no operators
- no execution
Example:
𒌷𒀀𒆠 → core space + A + field
Translation approach:
"Core space", "closed area", "module core".
3.5 The Four Levels in Interaction
| Level | Sign | Function | Dynamic |
|-------|------|----------|---------|
| 1. Meta Level | 𒀭 (AN) | Upper space | static |
| 2. Area Level | 𒈾 | Decision module | semi-static |
| 3. Field Level | 𒆠 | Process surface | dynamic |
| 4. Core Space Level | 𒌷 | Closed core | stable |
The levels are hierarchical, but not linguistically — functionally.
3.6 Where DINGIR (Flag) Intervenes in These Levels
DINGIR (𒀭 as flag) is not a module, but a meta operator that says:
"This module now operates on Level 1."
That means:
- 𒀭𒈗 → execution becomes meta
- 𒀭𒂗 → operator becomes meta
- 𒀭𒈾 → area becomes meta
- 𒀭𒆠 → field becomes meta
- 𒀭𒌷 → core space becomes meta
DINGIR is therefore a level switcher.
3.7 The King List Is Based Exactly on These Four Levels
Every entry consists of:
1. Area (𒈾)
2. Operator (EN, LUGAL, SIPA …)
3. Process (𒈗)
4. Cycle (𒈬)
5. Completion (𒌓)
6. Reset (𒀸)
7. Meta flags (𒀭)
The King List is not a text, but a protocol that uses these four levels.
CHAPTER 4 — The Operator Roles
EN, LUGAL, SIPA, LU, … as Functional Modules
The Sumerians had no "titles" in the modern sense. Their so-called "titles" are operators that perform specific functions within an area (𒈾).
We define the most important operators:
1. EN — Stabilization / Management
2. LUGAL — Superordinate Control / Final Decision
3. SIPA — Process Management / Flow Control
4. LU — Base Agent / Executing Unit
5. DINGIR Operators — Meta Activation
6. Combinations — Composite Operator Roles
.1 𒂗 — EN — Stabilization / Management
Sign: 𒂗
Iconic Form:
- vertical structure
- horizontal cross wedges
- acts like a stabilization frame
System Function:
EN is the stabilizer of an area. It keeps the area coherent, ordered, aligned.
Role in the Process Model:
- stabilizes the area (𒈾)
- keeps parameters constant
- ensures coherence
- is not a "ruler", but a regulator
Translation approach:
"Stabilizer", "management module", "regulator".
Example:
𒈾𒂗𒈗 → area + EN + execution = stabilized execution
4.2 𒈗𒆤 (LUGAL) — Superordinate Control / Final Decision
Sign:
LUGAL consists of:
- 𒇽 (LU)
- 𒃲 (GAL)
Iconic Form:
- LU = base agent
- GAL = large / extended / superordinate
- together: extended agent
System Function:
LUGAL is the final decision-maker of an area. It makes decisions that cannot be reversed.
Role in the Process Model:
- superordinate control
- final output
- final decisions
- only operates in certain areas
Translation approach:
"Final module", "super operator", "decision authority".
Example:
𒈾𒈗𒆤𒈬 → area + execution + LUGAL + cycle = finalized execution over one cycle
4.3 𒋀 — SIPA — Process Management / Flow Control
Sign: 𒋀
Iconic Form:
- diagonal wedges
- directed structure
- acts like a flowchart
System Function:
SIPA is the process manager. It controls the flow, not the decision.
Role in the Process Model:
- controls sequences
- monitors process steps
- ensures correct execution
- is not a decision-maker, but a flow manager
Translation approach:
"Process manager", "flow control", "flow manager".
Example:
𒈾𒋀𒈗 → area + SIPA + execution = managed execution
4.4 𒇽 — LU — Base Agent / Executing Unit
Sign: 𒇽
Iconic Form:
- simple wedge structure
- open
- minimalist
System Function:
LU is the smallest executing unit. Not a human, but an agent.
Role in the Process Model:
- executes commands
- is part of LUGAL
- forms the basis of all operator roles
Translation approach:
"Agent", "unit", "executor".
Example:
𒇽𒈗 → agent executes process
4.5 𒀭 + Operator = Meta Operator (DINGIR Operator)
Signs:
- 𒀭𒂗 → activated EN
- 𒀭𒋀 → activated SIPA
- 𒀭𒈗 → meta execution
System Function:
DINGIR raises an operator to the meta level.
Role in the Process Model:
- prioritized processes
- superordinate decisions
- meta control
Translation approach:
"meta-active", "prioritized", "superordinate".
4.6 Composite Operator Roles
The Sumerians combined operators into functional chains.
Examples:
| Combination | Meaning |
|-------------|---------|
| EN + SIPA | stabilized process management |
| LUGAL + SIPA | finally controlled flow |
| EN + LUGAL | stabilized final decision |
| 𒀭 + LUGAL | meta final module |
4.7 The King List Uses These Operators in Exactly This Way
Every entry consists of:
- Area (𒈾)
- Operator (EN, LUGAL, SIPA, LU)
- Process (𒈗)
- Cycle (𒈬)
- Completion (𒌓)
- Reset (𒀸)
- Meta flags (𒀭)
The so-called "kings" are not persons, but operator roles in a system.
CHAPTER 5 — The King List as System Protocol
How the Sumerians documented processes, cycles and resets
The so-called "King List" is not a historical text, but a technical logbook that describes:
- which area was active (𒈾)
- which operator operated within it (EN, LUGAL, SIPA …)
- which process was executed (𒈗)
- how long the process ran (𒈬)
- when it was completed (𒌓)
- when a reset occurred (𒀸)
- whether something ran on meta level (𒀭)
We build this up step by step.
5.1 Basic Structure of Every Entry
Every entry in the King List follows the same iconic structure:
1. Area opening — 𒈾
2. Operator role — 𒂗 (EN), 𒈗𒆤 (LUGAL), 𒋀 (SIPA), 𒇽 (LU)
3. Process execution — 𒈗
4. Cycle duration — 𒈬 + number
5. Cycle end — 𒌓
6. Reset (optional) — 𒀸
7. Meta flags (optional) — 𒀭 + operator or process
This is not a name, but a functional block.
5.2 Example: En‑men‑dur‑ana (read iconically)
Traditional: "Enmendurana, King of Sippar, ruled 21,000 years."
Iconically correct:
𒂗𒈨𒉡𒈾𒀭𒈗
Breakdown:
- 𒂗 (EN) → stabilizer
- 𒈨 (MEN) → fixation / determination
- 𒉡 (DUR) → permanent binding
- 𒈾 (NA) → area
- 𒀭 (DINGIR) → meta flag
- 𒈗 (A) → execution
System reading:
A stabilized, determined, permanently bound area executes a meta-activated process.
This is a process module, not a person.
5.3 Example: Alulim (first entry of the list)
Traditional: "Alulim ruled 28,800 years."
Iconically:
𒀭𒇽𒈾𒈬 28800 𒌓
Breakdown:
- 𒀭𒇽 → meta-activated agent
- 𒈾 → area
- 𒈬 28800 → 28,800 cycles
- 𒌓 → completion
System reading:
A meta-activated agent operates in an area over 28,800 cycles and completes.
5.4 Example: Alalgar
Traditional: "Alalgar ruled 36,000 years."
Iconically:
𒀭𒇽𒈾𒈬 36000 𒌓
Same structure as Alulim, only different cycle duration.
System reading:
Meta agent → area → 36,000 cycles → completion.
5.5 The "Flood" as Reset Mechanic
The famous line:
𒌓𒀸
Traditional: "Then the flood came."
Iconically:
- 𒌓 → completion
- 𒀸 → reset
System reading:
Cycle completed → system re-initialized.
This is not a natural event. This is a system reset.
5.6 After the Reset: New Areas, New Operators
After 𒀸 there appear:
- new area signs
- new operator roles
- new process modules
- new cycles
This is exactly what one would expect in a technical logbook.
5.7 Why the Numbers Are So Large
Because MU (𒈬) is not a "year", but a cycle.
A cycle can be:
- a moon cycle
- a process cycle
- a computation cycle
- an astronomical cycle
The numbers are not absurd, but systemically correct.
5.8 The King List Is Not a Text — It Is a Flowchart
Every entry is:
- an area
- with an operator
- that executes a process
- over a specific duration
- until completion
- with optional reset
- and optional meta activation
This is software logic, not "king history".
5.9 The King List as Overall Model
The structure of the entire list is:
1. Meta agent phase
𒀭𒇽𒈾𒈬 … 𒌓
𒀭𒇽𒈾𒈬 … 𒌓
𒀭𒇽𒈾𒈬 … 𒌓
2. Reset
𒌓𒀸
3. New operator phase
𒈾𒂗𒈗𒈬 … 𒌓
𒈾𒋀𒈗𒈬 … 𒌓
𒈾𒈗𒆤𒈬 … 𒌓
4. Further resets
𒌓𒀸
𒌓𒀸
5. Later modules
- increasingly shorter cycles
- increasingly fewer meta flags
- increasingly more field and core space modules
This is a descending system, not a "change of dynasty".
Keine Kommentare:
Kommentar veröffentlichen