changes

5 files changed, 203 insertions, 63 deletions

diff --git a/index.html b/index.html
index aca73cb..73a47ab 100644
--- a/index.html
+++ b/index.html
@@ -12,6 +12,7 @@
     <meta charset='UTF-8'>
     <title>tempo</title>
     <link rel="prefetch" href="/tempo.md" as="fetch">
+    <link rel="prefetch" href="/symbols.txt" as="fetch">
     <link rel="stylesheet" href="styles3.css">
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <link rel="shortcut icon" href="bell.png">
@@ -28,7 +29,7 @@
         }
     </script>
     <div id="themeButton" style="display: none">
-    	<button id="themeToggle">🌙</button>
+        <button id="themeToggle">🌙</button>
     </div>
 
     <script>
@@ -52,15 +53,16 @@
     </script>
 
     <noscript>
-    	hello.<br>
-    	your browser does not support javascript, it seems.<br>
-    	this means i cannot render the markdown as pretty-printed html for you.<br>
-    	instead, you can read the markdown raw at <a href="tempo.md">this page</a>.<br>
-    	have a great day! :)
+        hello.<br>
+        your browser does not support javascript, it seems.<br>
+        this means i cannot render the markdown as pretty-printed html for you.<br>
+        instead, you can read the markdown raw at <a href="tempo.md">this page</a>.<br>
+        have a great day! :)
 
-    	<br><br><br><br><br>
+        <br><br><br><br><br>
     </noscript>
 
+    <div id='warnings'></div>
     <div id='content'></div>
     <div>
         tempo is licensed under creative-commons.
@@ -100,7 +102,7 @@
                     chunk = chunk.replace(/\*\*(.*?)\*\*/g, '<b>$1</b>')
                     chunk = chunk.replace(/__(.*?)__/g, '<u>$1</u>')
                     chunk = chunk.replace(/\*(.*?)\*/g, '<i>$1</i>')
-                    chunk = chunk.replace(/\[\[(.*?)\]\]/g, '<span style="user-select:none">🔎 </span><b>“$1”</b>')
+                    chunk = chunk.replace(/\[\[(.*?)\]\]/g, '<span style="user-select:none">🔎 </span><b>"$1"</b>')
                     html += chunk
                 } else {
                     html += `<code>${escapeHTML(parts[i])}</code>`
@@ -109,6 +111,46 @@
             return html
         }
 
+        async function loadSymbols() {
+            try {
+                let response = await fetch('symbols.txt')
+                if (response.status !== 200) response = await fetch('symbols.txt.html')
+                if (response.status !== 200) {
+                    console.log('symbols.txt not found, skipping symbol replacement')
+                    return {}
+                }
+
+                const text = await response.text()
+                const symbols = {}
+
+                for (const line of text.split('\n')) {
+                    const trimmed = line.trim()
+                    if (!trimmed) continue
+
+                    const parts = trimmed.split(/\s+/)
+                    if (parts.length >= 2) {
+                        const symbol = parts[0]
+                        const name = parts.slice(1).join(' ')
+                        symbols[name] = symbol
+                    }
+                }
+
+                return symbols
+            } catch (err) {
+                console.warn('failed to load symbols.txt:', err)
+                return {}
+            }
+        }
+
+        function applySymbols(text, symbols) {
+            let result = text
+            for (const [name, symbol] of Object.entries(symbols)) {
+                const pattern = new RegExp(`\\\\${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\\\`, 'g')
+                result = result.replace(pattern, symbol)
+            }
+            return result
+        }
+
         class TempoParser {
             constructor(rawText) {
                 this.lines = rawText.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n')
@@ -266,25 +308,62 @@
                 const deftext = escapeHTML(code)
 
                 return `<block>
-                    <header>
-                        <div class='header-left'>
-                            <span>def</span>
-                            <span class='def-name'>${escapeHTML(name)}</span>
-                            ${deftext.length === 0 ? `` : `<code>${escapeHTML(code)}</code>`}
-                        </div>
-                        ${eng ? `<span class='eng-text'>[${escapeHTML(eng)}]</span>` : ''}
-                    </header>
-                    <desc>${descHtml}</desc>
-                </block>`
+            <header>
+                <div class='header-left'>
+                    <span>def</span>
+                    <span class='def-name'>${escapeHTML(name)}</span>
+                    ${deftext.length === 0 ? `` : `<code>${escapeHTML(code)}</code>`}
+                </div>
+                ${eng ? `<span class='eng-text'>[${escapeHTML(eng)}]</span>` : ''}
+            </header>
+            <desc>${descHtml}</desc>
+        </block>`
+            }
+        }
+
+        function validateSymbols(text, symbols) {
+            const usagePattern = /\\([^\\\s]+)\\/g
+            const usedSymbols = new Set()
+            let match
+
+            while ((match = usagePattern.exec(text)) !== null) {
+                usedSymbols.add(match[1])
+            }
+
+            const definedSymbols = new Set()
+            const defPattern = /^def\s+(\S+)/gm
+
+            while ((match = defPattern.exec(text)) !== null) {
+                console.log('defined:', match[1])
+                definedSymbols.add(match[1].replace(/^\\/g, '').replace(/\\$/g, ''))
+            }
+
+            const missing = []
+            for (const name of usedSymbols) {
+                if (definedSymbols.has(name)) continue
+
+                const symbol = symbols[name]
+                if (symbol && definedSymbols.has(symbol)) continue
+
+                missing.push(name)
+            }
+
+            if (missing.length > 0) {
+                const msg = `undefined symbols detected:\n${missing.map(s => `  • (${symbols[s]}) ${s}`).join('\n')}`
+                warnings.innerHTML += msg.replace(/\n/g, '<br>')
+                console.warn('undefined symbols:', missing)
             }
         }
 
         async function loadMarkdown() {
             try {
+                const symbols = await loadSymbols()
                 let response = await fetch('tempo.md')
                 if (response.status !== 200) response = await fetch('tempo.md.html')
 
-                const text = await response.text()
+                let text = await response.text()
+                validateSymbols(text, symbols)
+                text = applySymbols(text, symbols)
 
                 const parser = new TempoParser(text)
                 parser.tokenize()
@@ -356,4 +435,4 @@
     </script>
 </body>
 
-</html>
+</html>
\ No newline at end of file
diff --git a/styles.css b/styles.css
index 749b791..ba30830 100644
--- a/styles.css
+++ b/styles.css
@@ -245,3 +245,11 @@ desc {
 body.dark-mode .timestamp-badge {
 	border-color: #ff8833;
 }
+
+#warnings {
+	display: block;
+	position: fixed;
+	bottom: 30px;
+	left: 30px;
+	color: red;
+}
\ No newline at end of file
diff --git a/styles3.css b/styles3.css
index 749b791..ba30830 100644
--- a/styles3.css
+++ b/styles3.css
@@ -245,3 +245,11 @@ desc {
 body.dark-mode .timestamp-badge {
 	border-color: #ff8833;
 }
+
+#warnings {
+	display: block;
+	position: fixed;
+	bottom: 30px;
+	left: 30px;
+	color: red;
+}
\ No newline at end of file
diff --git a/symbols.txt b/symbols.txt
new file mode 100644
index 0000000..a63e7e4
--- /dev/null
+++ b/symbols.txt
@@ -0,0 +1,27 @@
+Ω me
+∷ prop
+∷ property
+⩫ unique
+≠ neq
+≠ notequal
+🮻 static
+ʭ id
+⨍ lookup
+⧔ time
+∞ inf
+∞ infinity
+ε smol
+ε epsilon
+⊼ nand
+⑄ speaker
+¶ growth
+໒ world
+✦ beginning
+𝛏 axiom
+𜸴 mind
+Λ listener
+ϒ comprehend
+ϑ dawn
+𜱺 energy
+𜲏 matter
+≈ almost
\ No newline at end of file
diff --git a/tempo.md b/tempo.md
index e3ca93e..53283cf 100644
--- a/tempo.md
+++ b/tempo.md
@@ -32,7 +32,7 @@ the usage section of an axiom describes how arguments are taken in.
 the complex 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=.∷Ω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 `Ωapple`). 
+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)
 
@@ -52,21 +52,21 @@ combines two objects into a composite object. (A + B)
 
 ## the self-referential axiom (me)
 
-def Ω `Ω`
+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. `Ω` can be reduced, but to itself.
+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 Ω `[x] Ω+x` (Ω A)
+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, `Ω 1` is `1` itself, not its implication.
-this axiom takes precedence above any other, meaning `-Ω-` does not mean the un-essence of negation and leave a hanging argument.
+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 . `- Ω-`
+def . `- \me\-`
 ^^ origin:
 a thing that exists, a negation of non-existence.
 can be any existence, but can never equate itself.
@@ -83,46 +83,50 @@ 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 ∷ `[x y] x+. = y` (A ∷ B)
+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 ⩫ `[x] A=. x≠A` (⩫ 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 🮻 `[x] x>x` (🮻 A)
+def \static\ `[x] x>x` (\static\ A)
 ^^ static:
 denotes an object that never changes. that is, it is its own consequence.
 
-def ʭ `[x y] A=x A∷y ⩫A 🮻A` (A ʭ B)
+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 ⨍ `[x] A=. xʭA A` (⨍ B)
+def \lookup\ `[x] A=. x\id\A A` (\lookup\ B)
 ^^ lookup:
 resolves an ID to its unique property owner.
 
-def * `[x y] A=⨍x A∷y A` (B * C)
+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 `Ω> + 0`
+def 1 `\me\> + 0`
 ^^ one:
 consequence of zero.
 
-def ≠ `[x y] - x=y` (A ≠ B)
-^^ unequal:
-shows that the two input objects are non-equal.
-
-def < `[x y] y>x + x≠y` (A < B)
+def < `[x y] y>x + x\neq\y` (A < B)
 ^^ before:
-B > A & A ≠ B, denotes B comes after A and they are not the same.
+B > A & A \neq\ B, denotes B comes after A and they are not the same.
+
+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 an atomic object will return either itself or `0`, depending on the atomic object's lifetime nature.
 
-def ! `.|0`
+def ! `.*0`
 ^^
 an indescribable, unknown, and paradoxical axiom.
 denotes a part extracted from nothingness.
@@ -131,7 +135,7 @@ 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: `Ω@*A = B` means if A is subjected to change, it transforms into B (provided the statement is true).
+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)
@@ -146,7 +150,7 @@ 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 ⧔ `\@`
+def \time\ `\@`
 ^^ time:
 the loop of change.
 
@@ -158,27 +162,23 @@ def F `-T`
 ^^ false:
 the universal value of falsehood.
 
-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 an atomic object will return either itself or `0`, depending on the atomic object's lifetime nature.
-
-def ∞ `A=. .>A`
+def \inf\ `A=. .>A`
 ^^ infinity:
 a concept that is bigger (and comes after) anything else.
 
-def ε `A=. -A=0 A>.`
+def \epsilon\ `A=. -A=0 A>.`
 ^^ epsilon:
-a concept that is smaller (and comes before) anything else, except zero. this implies `0>ε`.
+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 ⊼ `[x y] - x&y` (A ⊼ B)
+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.
 
-def ⑄ `A=. . < Ωx A` (⑄ B)
+def \speaker\ `A=. . < \me\x A` (\speaker\ B)
 ^^ speaker:
 what came before "me"? the originator of the thought, of course.
 
@@ -186,47 +186,65 @@ what came before "me"? the originator of the thought, of course.
 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 ¶ `[x] ¶ .+x` (¶ A)
+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] ¶ x+x`, which is just `x`. you may also add this as a constraint: `[x] A=. A=x ¶x = x`
+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 `⑄Ω`
+def i `\speaker\\me\`
 ^^ i:
 refers to the speaker.
 
-def ໒ `¶ i`
+def \world\ `\growth\ i`
 ^^ world:
 captures the speaker's universe.
 
-def ✦ `ε*໒`
+def \beginning\ `\epsilon\*\world\`
 ^^ the beginning:
 denotes the first non-zero moment of the speaker's universe.
 
-def 𝛏 `[x] ʭΩ * x` (𝛏 A)
+def \axiom\ `A=. \id\\me\*A A`
 ^^ axiom:
 defines the property of being an axiom.
 
-def 𜸴 `A=. B=𝛏. A>B A`
+def \mind\ `A=. A>\axiom\ A`
 ^^ mind:
 anything capable of leading to the creation of an abstract axiom.
 
-def Λ `𜸴 * @Ω`
+def \listener\ `\mind\ * @\me\`
 ^^ listener:
 any mind that is able to receive the information of this current axiom.
 
-**frustration**: *now how do i define love?*
+**frustration**: *how do i define love?*
 
-def ϒ `[x] A=x A=Λ B=𝛏. C=@A @A = B+A @A≠C` (D ϒ)
+def \comprehend\ `[x] A=x A=\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 \matter\ `A=. A\neq\0 \static\\id\A A\almost\\energy\`
+^^ matter:
+**universe dependent**, existence which has a persistent identity, is weakly equal to energy, and 
 
 ## update log
 
 // Timestamp: future
 - more coming soon.
 
+// 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 𝛏, 𜸴 and Λ was not easy. the moment i wrote them down it took me a good 5 minutes to understand why and how they work.
+- 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.