path: root/tempo.md

# ⍾ tempo
a temporal, causal-chain based constructed language (conlang) for the structured communication of concepts.

there are currently {{dict_size}} axioms (words) in tempo's dictionary.

**lookup table**:

## definitions

let's start by setting some expectations.

***what tempo is***:
- a conlang
- a way to formalize thoughts
- the most efficient way to drain my mental juice, by far. i mean, when i even try to progress this thing, i need an entire day of watching tv series to recover and recharge from it.

***what tempo is not***:
- a programming language
- a proof language
- a concrete rules system (despite how hard it tries to be)

def axiom ``
^^ axiom:
an axiom is any piece of information that can be denoted in tempo.
an axiom can be comprised of one or more axioms.
if an axiom can be expanded into other axioms and still preserve the original meaning,
it is called a [[composite axiom]].
otherwise, if an axiom can not be broken down into other axioms,
it is called a [[fundamental axiom]].

i have defined my own set of fundamental axioms. these are **consequence** (the axiom of causality), **negate** (the axiom of logic) and **combine** (the axiom of composition).
i believe (*unverified*) that three is the absolute minimum, and that successfully defining one of the three fundamental axioms using the other two will require a breakthrough in physics. if any future nobel prize winner has a secret they haven't shared with the world yet, this would be a good time to contact me.

parenthesis can be used to imply order of words, but usually they can be distinguished based on axiom-definition and 

## markup
an axiom is denoted as:
```
def <name> `<definition>` [english form]
^^ <description>
```

## syntax
in tempo, everything is interpreted as left-to-right.
an axiom can have 0 to an arbitrary number of inputs, which indicates that the axiom is basically a catch-all. arguments are taken in the format of `[arg1 arg2 arg3 ...]` in the definition.
the usage section of an axiom describes how arguments are taken in.

the composite axiom assertion bears a cognitive load: it allows assigning names to the time slice of an axiom. for example: `A = .` returns a random (or non-random) object in the enclosing set of the context.
in our world, this could be an atom, an apple, an idea, a time, a memory, a sound, anything.

<!> it also serves as a filter, in which `A=. A=.\prop\\me\apple` would filter the first statement, `A=.`, such that A is a property of an apple (since tempo doesn't define apples yet, we contractually import it from our own language as `\me\apple`). 

## fundamental axioms (words)

def > `fundamental.` (A > B)
^^ consequence:
denotes an event in the course of a temporal chain.
`A > B` directly implies that perception of B is impossible if the perception of A is also not possible.
this axiom can also act as a logical consequence, being the equivalent of `A ⇒ B`.

def - `fundamental.` (- A)
^^ negate:
converts an object into its logical opposite.

def + `fundamental.` (A + B)
^^ combine:
combines two objects into a composite object.

## the self-referential axiom (me)

def \me\ `\me\`
^^ me:
an axiom that references itself. this is neither composite nor fundamental, rather it is derived from itself. fundamental axioms are unified, they can not be reduced. `\me\` can be reduced, but to itself.

def \me\ `[x] \me\+x` (\me\ A)
^^ me too (identity):
the me axiom is very special. for this reason, it will have two definitions.
one to refer to itself, and one to combine itself with any other axiom(s) that come its way.
captures another axiom in the form of an identity, in its very essence, and not what it is trying to imply.
for example, `\me\ 1` is `1` itself, not its implication.
this axiom takes precedence above any other, meaning `-\me\-` does not mean the un-essence of negation and leave a hanging argument.

## composite axioms (semi-sentences)

def . `- \me\-`
^^ object:
a thing that exists, a negation of non-existence.
can be any existence, but can never equate itself.
that is, `. = .` is never true, even in a single-object universe,
since the ephemeral object can be the universe and the single-object at once.
not even in a zero-object universe, as the object can be
the universe itself and nothingness.

def 0 `-.`
^^ zero:
negation of existence.

def = `[x y] x>y + y>x` (A = B)
^^ equality:
A>B whilst B>A. in other words, the two events are the same.

def \prop\ `[x y] x+. = y` (A \prop\ B)
^^ property:
denotes that a certain object is a property of another, by indicating that its combination with another object results in the target.
this also implies that you can consider `0` as property of all, and `1` as property of all the numbers above it, and so on.

def \type\ `[x y] y\prop\x` (A \type\ B)
^^ typeof:
the reverse implication of `\prop\`, showing that axiom A is of type axiom B.

def \neq\ `[x y] - x=y` (A \neq\ B)
^^ unequal:
shows that the two input objects are non-equal.

def \unique\ `[x] A=. x\neq\A` (\unique\ B)
^^ unique:
denotes that there is no such other object equating this one.

def \static\ `[x] x>x` (\static\ A)
^^ static:
denotes an object that never changes. that is, it is its own consequence.
an alternative definition would be `[x] @x=x`, claiming that an object's change is itself.

def \id\ `[x y] A=x A\prop\y \unique\A \static\A` (A \id\ B)
^^ id:
denotes the specific property of item B in which it has an immutable and unique property that is not shared with any other object.

def \lookup\ `[x] A=. x\id\A A` (\lookup\ B)
^^ lookup:
resolves an ID to its unique property owner.

def * `[x y] A=\lookup\x A\prop\y A` (B * C)
^^ catch:
resolves the value of an object's property based on its ID.
for example, `color catch apple` equates `red`.
`1` catch array of `[2, 3]` equates `2`, the first item of the set. (A * B)

def 1 `\me\> + 0`
^^ one:
consequence of zero.

def 2 `1+1`
^^ two:
one and one.

def 3 `2+1`
^^ three:
two and one.

every number can be defined this way, you get the idea.
also, by the way, this is text. hello from text. you'll be seeing more of me later.

def < `[x y] y>x + x\neq\y` (A < B)
^^ before:
B > A & A \neq\ B, denotes B comes after A and they are not the same.

def \between\ `[a x y] x\neq\f f\neq\y x>f f>y` (A \between\ B C)
^^ between:
shows that an event takes place between two other events.

def | `[x] A=. A<x A` (| B)
^^ separate:
the object(s) preceeding the combination of an input object. breaks down an input into its creating parts. using this on a static atomic object will return either itself.

def ! `.*0`
^^ ???:
an indescribable, unknown, and paradoxical axiom.
denotes a part extracted from nothingness.

def @ `[x] x * .>.` (@ A)
^^ change:
denotes any multiple of epsilon time in causal progression, meaning our input object has changed.
if we consider `des` to be an object which is destroyed upon change —routine for all objects, but we overlook it to avoid existential burden— then `@ des` would equate `0`.
this axiom can also be used as an event descriptor: `\me\@*A = B` means if A is subjected to change, it transforms into B (provided the statement is true).
explanation: we capture the input object from the cycle of `.>.` which denotes a causal event.

def # `[x] @x = @x` (# A)
^^ law of persistence:
the change of an object results in its change. this is true unless an external force acts upon the system in an unpredictable manner.

def ~ `[x] -#x` (~ A)
^^ chaos:
the unpredictability an object's change. this is true only for a system which is influenced by an unpredictable external force.

def \ `[x] A=.|x B=.|x A>B>A` (\ C)
^^ loop:
A and B obtain a reference to two objects in the system C, and then denote that A causes B whilst B causes A. example: `\ growth` denotes a causal loop which causes infinite growth.

def \time\ `\@`
^^ time:
the loop of change.

def T `A=. A=A`
^^ true:
the universal value of truth.

def F `-T`
^^ false:
the universal value of falsehood.

def \inf\ `A=. .>A`
^^ infinity:
a concept that is bigger (and comes after) anything else.

def \epsilon\ `A=. -A=0 A>.`
^^ epsilon:
a concept that is smaller (and comes before) anything else, except zero. this implies `0>\epsilon\`.

def & `[x y] x=T + y=T` (A & B)
^^ and:
logical AND.

def \nand\ `[x y] - x&y` (A \nand\ B)
^^ nand:
logical NAND. this expression is proven to be functionally complete, meaning you can build any conceivable logical contraption out of this. for the sake of originality though, we will not be using this to scaffold a rule 110 emulator.

i will not be defining other logical operators here, they are trivial.

def \speaker\ `A=. . < \me\x A` (\speaker\ B)
^^ speaker:
what came before "me"? the originator of the thought, of course.

**things to ponder**:
1. what is a human speaker, if not the causal chain of axioms that produced another axiom?
2. what is the physical realm, and how can tempo even anchor to it?

def \growth\ `[x] \growth\ .+x` (\growth\ A)
^^ growth:
denotes infinite growth of an input axiom. can be used to find the encapsulating set of an input object. note that at some point it becomes a no-operation, once the growth turns into the encapsulating set and becomes `[x] \growth\ x+x`, which is just `x`. you may also add this as a constraint: `[x] A=. A=x \growth\x = x`

def \i\ `\speaker\\me\`
^^ i:
refers to the speaker.

def \world\ `\growth\ i`
^^ world:
captures the speaker's universe.

def \beginning\ `\epsilon\*\world\`
^^ the beginning:
denotes the first non-zero moment of the speaker's universe.

def \axiom\ `A=. \id\\me\*A A`
^^ axiom:
defines the property of being an axiom.

def \mind\ `A=. A>\axiom\ A`
^^ mind:
anything capable of leading to the creation of an abstract axiom.

def \listener\ `\mind\ * @\me\`
^^ listener:
any mind that is able to receive the information of this current axiom.

**frustration**: *how do i define love?*

def \comprehend\ `[x] A=x A=.\type\\listener\ B=\axiom\. C=@A @A = B+A @A\neq\C` (D \comprehend\)
^^ comprehension:
indicates an axiom being transmitted to a listener, resulting in the change of the listener.
it resolves to a `T`/`F` value, indicating whether the listener's mind has changed in comparison to an outcome in which the listener did not receive the axiom.
this is also the first axiom, up to this point, to come *after* its generic argument.

def \dawn\ `\inf\ * @\beginning\`
^^ dawn:
the highest/largest existence after the beginning.

def \energy\ `A=. \energy\+A > @A`
^^ energy:
perhaps the first axiom to be defined declaratively. an axiom when, which applied to an object, causes it to change.

def \almost\ `[x y] A=.\prop\x B=.\prop\y A=B x\neq\y` (C \almost\ D)
^^ weak equality:
shows that all properties of two objects are true, but they are not completely equal.

def \matter\ `A=. A\neq\0 \static\\id\A A\almost\\energy\`
^^ matter:
**universe dependent**. existence which has a persistent identity and is weakly equal to energy.

def \atom\ `A=. A\type\\matter\ \epsilon\*A=A (\me\)\prop\A`
^^ atom:
an indivisible type of matter which has the property of identity.

def \aH\ `A=. A\type\\atom\ (\atom\+1)\id\A`
^^ hydrogen:
an atom identified by the unity (1).

def \aHe\ `A=. A\type\\atom\ (\atom\+2)\id\A`
^^ helium:
an atom identified by the composite 2.

other atoms can be defined using the same method.

def \hypo\ `[x] (\me\@)>x` (\hypo\ A)
^^ hypothetical:
a case where change might lead to an input axiom.

def \you\ `A=.\type\\listener\ B=\axiom\. \speaker\>B \hypo\(B>A A\comprehend\) A`
^^ you:
indicates a listener that can hypothetically comprehend an axiom created by the speaker.
the target of the speaker's words.

def \context\ `[x] A=.\type\(\me\\axiom\) !\comp\x \comp\(x+A) A` (\context\ B)
^^ context:
an axiom, without which, the input axiom cannot be comprehended, but with it, the listener can comprehend the input axiom.

def \nuos\ `[x] A=.\type\(\me\\world\) B=x B\type\\mind\ A^B A` (\nuos\ C)
^^ nuos:
the internal world, context and logic of a specific mind. defines a world which exists inside of another.

def ? `A=.\type\\axiom\ B=.\type\\axiom\ B>A (!((\speaker\B)\comp\))>B B`
^^ question:
an axiom, which originates from a void of comprehension, and leads to another axiom.

def ; `A=.\type\\axiom\ B=.\type\\axiom\ B>A (!((\speaker\B)\comp\))>B A`
^^ answer:
the axiom created from the void of comprehension.

**note to all**: do not try to define love. poetry is not definition.

def \all\ `[x y] -(A=.\type\x -(A\prop\y))` (\all\ B C)
^^ all:
for all axioms of type B, every one of them exists inside C.

def \some\ `[x y] -(\all\ x -y)` (\some\ A B)
^^ some:
there exists an axiom of type A which is inside of B.
alternative definition: `[x y] A=.\type\x A\prop\y`

## update log

// Timestamp: future
- more coming soon.

// Timestamp: 2026-02-23 09:37:18 UTC+3:30
- added symbols \some\ and \all\.

// Timestamp: 2026-02-22 13:15:30 UTC+3:30
- added symbols \between\, \ctx\ and \nuos\.

// Timestamp: 2026-01-03 16:29:56 UTC+3:30
- added symbols \hypo\ and \you\.

// Timestamp: 2026-01-01 10:36:31 UTC+3:30
- happy new year!
- added a smooth css transition for theme changing.
- added a service worker with a serve-cache-then-update strategy. ~~this means you might need two refreshes of the website for new content~~ (the website auto-reloads on new content), but it's worth it.
- added first-paint rendering so that you get the content as fast as possible, without having to wait for a full markdown render.
- added a git hook such that pushing the repository automatically updates the website as well.

// Timestamp: 2025-12-30 22:19:43 UTC+3:30
- added a few new axioms. moved old ones around.
- added a symbol resolution system, so now i can write `\<name>\` and have it replaced based on my table instead of writing each one out every time by searching my unicode table.
- deleted the LD linker from my server. most my websites are down now. we wait.

// Timestamp: 2025-12-30 16:18:33 UTC+3:30
- defining \axiom\, \mind\ and \listener\ was not easy. the moment i wrote them down it took me a good 5 minutes to understand why and how they work.

// Timestamp: 2025-12-29 23:42:20 UTC+3:30
- it's almost the new year.
- added dark mode support.

// Timestamp: 2025-12-29 13:39:17 UTC+3:30
- changed positional arguments from using numbers to using bound variables.
- defined new axioms and made previous axioms more robust.

// Timestamp: 2025-12-29 11:36:40 UTC+3:30
- i will now move onto actual human communication.

// Timestamp: 2025-12-28 21:01:24 UTC+3:30
- catch is not a fundamental axiom! i was able to construct it using the remaining three, and i have moved it to the composite axioms section.
- renamed [[complex axioms]] to [[composite axioms]].

// Timestamp: 2025-12-28 15:18:49 UTC+3:30
- reworked the markdown parser to render the website more faithfully.
- added a definitions section.
- added a timestamp element to allow for descriptive logging of changes.
- removed **separate** as a fundamental axiom, as it can be formed by mixing **before** and **combine**.
- defined a few new axioms.

// Timestamp: 2025-12-27 23:30 UTC+3:30
- created the first iteration.
- added the initial definition.

## footnotes
thank you for reading.

this website is configured in a way such that web scrapers will be able to archive all of its contents, including the <a href="tempo.md">tempo.md</a> file. a copy of tempo can be found on the wayback machine.

this website has a git repository on <a href="https://git.coffin.ir/moon/tempo">my git mirror</a>.

-- communication --

telegram: <a href="https://t.me/moonflowerfields">@moonflowerfields</a>
email: <a href="mailto:moon@coffin.ir">moon@coffin.ir</a>