This is my conlang (specifically an engilang),
Hover over or tap any
This page is mobile-optimized only on a best-effort basis. Some tables will overflow.
All pronunciations are listed in "<IPA> or <X-SAMPA>".
Letters:
Numbers 0-9:
Each word is made of:
Words starting with <prefix> are <part of speech>
After the prefix comes the root. Roots are described next section, but they fall into six prefixed categories - roots that start with <letter> are categorized as <category>:
All roots are terminated by
All suffixes are optional unless otherwise noted. Legal suffixes are shown below, in their default order:
| Suffixes | Verbs | Nouns | Adjectives | Adverbs | Conjunctions |
|---|---|---|---|---|---|
| Case | ✅ | ✅ | ✅ | ✅ | ✅ |
| Tense | ✅ | ❌ | ❌ | ❌ | ❌ |
| Certainty | ✅ | ❌ | ❌ | ❌ | ❌ |
| Mood | ✅ | ❌ | ❌ | ❌ | ❌ |
| Count | ❌ | ✅ | ❌ | ❌ | ❌ |
| Intensity | ✅ | ✅ | ✅ | ✅ | ❌ |
| Direction | 1️⃣ | 1️⃣ | 1️⃣ | 1️⃣ | 2️⃣ |
| Opinion | ✅ | ✅ | ✅ | ✅ | ❌ |
Notes:
Some of the suffixes that follow can be repeated for granularity. Specifically, each subsequent suffix has half the effect of the one before it (such that the maximum distance from neutral is twice the effect of any suffix). The following Python function can be used to compute the granularity exactly.
def granularity(suffix_string: str, less: str, equal: str, more: str) -> float: """Example: less-more and equal-less both produce -0.5""" result = 0 power = 1 last_suffix = None for vowel, consonant in zip(*[iter(suffix_string)]*2): suffix = vowel + consonant if last_suffix != suffix: power /= 2 last_suffix = suffix if suffix == less: # lower than previous level result -= power elif suffix == more: # higher than previous level result += power elif suffix == equal: # same pass # doesn't change result, but could change power else: raise ValueError(suffix) return result
Two sets of case suffixes coexist: relative, -
\t across) one available spot in the tree\n down) to the first spot available in the next level of the treeThe use of these suffixes is described more fully in the discussion of syntax.
| Suffix | Tense it signifies | English example |
|---|---|---|
| past perfect | "had done" | |
| present perfect | "have done" | |
| future perfect | "will have done" |
| Suffix | Tense it signifies | English example | Suffix | Tense it signifies | English example |
|---|---|---|---|---|---|
| past continuous | "was doing" | past perfect continuous | "had been doing" | ||
| present continuous | "is doing" | present perfect continuous | "have been doing" | ||
| future continuous | "will be doing" | future perfect continuous | "will have been doing" |
More generally, tense is a granularity function defined as tense = lambda suffixes: granularity(suffixes.removesuffix('ec'), 'eb', 'en', 'ef'). For example, "future perfect" is the same as "present future" (both with granularity value +0.5).
An approximation of epistemic modality.
This is a granularity function defined as certainty = lambda suffixes: granularity(suffixes, 'ym', 'yl', 'yn'). However, unlike other granularity functions, the default (unmarked) certainty is "known", not the neutral "likely".
An approximation of deontic modality.
If not specified, the word takes no mood. The first person pronoun is implied to be the thing intending/requesting/willing/etc., unless modified with
| English | English | ||
|---|---|---|---|
| I intend that I leave | I shall ensure that I leave | ||
| They intend that I leave | They shall ensure that I leave | ||
| I ask that you leave | I order that you leave | ||
| They ask that you leave | They order that you leave | ||
| I'm okay if I leave | I wish that I leave | ||
| They're okay if I leave | They wish that I leave |
If not specified, the word takes no count.
Intensity is a granularity function defined as intensity = lambda suffixes: granularity(suffixes, 'on', 'ot', 'op').
This is used to condense vocabulary. A lot of words in other languages basically mean the same thing, but are in different directions. In
The
Also used to condense vocabulary, and also a granularity function, defined as opinion = lambda suffixes: granularity(suffixes, 'ag', 'at', 'ap').
Combined with direction and intensity, this collapses words like "large" (outwards), "fat" (outwards negative), "small" (inwards), "tiny" (intense inwards) into one single root for "size" - each of the previous would have the endings
A binary tree syntax inspired by that of Goptjaam is used, without any other features of that language. Instead, the binary tree is linearized row by row, left to right, using case markings to account for gaps in rows. Many properties of the tree structure are different from Goptjaam due to its lack of explicit part-of-speech markers.
For the following tree (where the diamond is a gap in the tree):
stateDiagram-v2 state gap <<choice>> Verb1 --> Noun1 Verb1 --> Noun2 Noun1 --> Adjective1 Noun1 --> gap Noun2 --> Adjective2 Noun2 --> Noun3
Some examples of how this tree can be rendered with the correct case suffixes:
For the following tree:
stateDiagram-v2 state gap1 <<choice>> state gap2 <<choice>> state gap3 <<choice>> state gap4 <<choice>> Verb1 --> Noun1 Verb1 --> Noun2 Noun1 --> Noun3 Noun1 --> gap1 Noun2 --> Noun4 Noun2 --> gap2 Noun3 --> gap3 Noun3 --> Adjective1 Noun4 --> Adjective2 Noun4 --> gap4
The minimal relatively-marked renderings would be "Verb1 Noun1 Noun2 Noun3 Noun4-
With linearization out of the way, the rest of the syntax rules relate to the structure of the tree. The basic rules are:
verb(joiner(noun, noun), noun) is preferred over verb(noun, joiner(noun, noun)) and definitely better than verb(joiner(joiner(noun, noun), noun),). The modifiers are read in depth-first-search order (i.e. in numerical order in verb(joiner(noun1, noun2), noun3)).
When a verb modifies a noun, the verb is the root of a relative clause, and a noun relativizer
stateDiagram-v2 nr1: [noun relativizer] nr2: [noun relativizer] went --> person went --> home person --> saw saw --> I saw --> nr1 person --> threw threw --> nr2 threw --> ball
The above tree might be rendered in English as "The person, which I saw [relativizer], [and] which [relativizer] threw the ball, went home," or in proper order as "went person home saw threw I-
A verb relativizer
stateDiagram-v2 vr: [verb relativizer] is --> vr is --> bad vr --> throw vr --> bite throw --> you throw --> people bite --> dog bite --> me
The above tree might be rendered in English as "you throwing people, and the dog biting me, are bad," or in proper order as "is [relativizer] bad throw bite you-
Compare the following trees.
stateDiagram-v2 state gap <<choice>> ball1: ball ball2: ball big1: big big2: big red1: red red2: red ball1 --> big1 ball1 --> red1 [bracketer] --> ball2 [bracketer] --> red2 ball2 --> big2 ball2 --> gap
The tree on the left corresponds to a "big red ball". That is, the ball is big and red. The tree on the right corresponds to a "red big ball". That is, the "big ball" is modified as a whole to be red.
The [bracketer] is
The grammar that used to be here is horrendously out of date, and is hidden until it is brought up to date.
General notes:
regexes that take the place of actual syllable entries, \d means a digit syllable (from The base category can also be used as a vehicle for suffixes, e.g.
(\d*!)* where ! is a color syllable: combination of colors, e.g. \d+: chemical element identified by atomic number, e.g. \d+(-\d+)?(&\d+(-\d+)?)*, where - is & is -?\d+(\.\d+)? where a "digit syllable" is one of the above from 0 to 11, - is \. is \d+: n-th ordinal number, i.e. =?((B|D)(-?\d+))+ where = is B is a base unit, D is a derived unit, and - is [\d-]+ where - is Under construction. The language changes often enough that chances are these examples are outdated relative to the current version.
In the glosses that follow,
| Gloss | Literally | |
|---|---|---|
| pos.v cat.movement pass-doorway; !abs.rrl +int +dir | intense exit | |
| pos.conj cat.y if-then; | implies | |
| pos.v cat.abstract describability-by; past +opn | were | |
| pos.v cat.abstract ability; past -opn | unable | |
| pos.n cat.object 2p; | you | |
| pos.d cat.abstract m3; +int +dir -opn | very more volume (bad) | |
| pos.n cat.object 2p; | you | |
| pos.v cat.y relativizer; | [verb relativizer] |
if you were fat, you couldn't escape
if you were very badly voluminous, then you were unable to intensely exit
The word "escape" is formed by declining "exit" ("pass through doorway" outwards) with intensity, and then additionally emphasized by being placed at the beginning of the sentence, necessitating the use of absolute case suffixes. (However, even without the emphasis, the word is at such an awkward part of the tree that it would have required absolute case suffixes regardless.)
stateDiagram-v2 state gap <<choice>> implies: conj.implies describability: v.describability (tense=-1, opinion=+1) ability: v.ability (tense=-1, opinion=-1) you1: n.2p you2: n.2p volume: adj.m<sup>3</sup> (dir=+1, intensity=+1, opinion=-1) vr: v.relativizer pass: v.pass doorway (dir=+1, intensity=+1) implies --> describability implies --> ability describability --> you1 describability --> volume ability --> you2 ability --> vr vr --> pass vr --> gap
| Gloss | Literally | |
|---|---|---|
| pos.n cat.y bracketer; | [bracketer] | |
| pos.n cat.abstract leader; +int | intense leader | |
| pos.conj cat.y joiner; | [joiner] | |
| pos.adj cat.abstract Catholicism; | Catholic | |
| pos.adj cat.abstract number-19Bdozenal; rel.t | 263 | |
| pos.adj cat.science life; -dir | dead |
263 dead Popes
263 nonliving Catholic high-leader
The word "Pope" is formed by bracketing "Catholic leader[intense]", to which the modifiers "263" and "dead" are then applied. No plural marking is necessary as the number implies it anyway.
stateDiagram-v2 state gap <<choice>> bracketer: n.bracketer leader: n.leader (intensity=+1) joiner: conj.joiner Catholic: adj.Catholicism 263: adj.number-19B<sub>dozenal</sub> dead: adj.life (direction=-1) bracketer --> leader bracketer --> joiner leader --> Catholic leader --> gap joiner --> 263 joiner --> dead
| Gloss | Literally | |
|---|---|---|
| pos.v cat.abstract possession; past -dir -opn | took away (bad) | |
| pos.conj cat.y joiner; | [joiner] | |
| pos.n cat.science life; +dir | life | |
| pos.n cat.object 1p; | I | |
| pos.adv cat.abstract violence; +int -dir -opn | violently (bad) | |
| pos.n cat.abstract info-transferer; -dir | information receiver's | |
| pos.adj cat.abstract intelligence; abs.rll -dir -opn | nonintelligent (bad) |
I brutally killed an idiotic student
I very-violently took stupid information-receiver's life
A student is someone who transfers information inwards. The tree has many gaps because the student is stupid, not their life. The joiner is used on the left to reduce the number of gaps (if it was on the right, "stupid" would be an additional level down), but "stupid" is still in an awkward enough position that it demands absolute case (relative case would take 5 suffixes).
stateDiagram-v2 state gap1 <<choice>> state gap2 <<choice>> took: v.possession (tense=-1, direction=-1, opinion=-1) joiner: conj.joiner life: n.life (direction=+1) I: n.1p violently: adv.violence (intensity=+1, direction=-1, opinion=-1) student: n.info-transferer (direction=-1) stupid: adj.intelligence (direction=-1, opinion=-1) took --> joiner took --> life joiner --> I joiner --> violently life --> student life --> gap1 student --> stupid student --> gap2
| Gloss | Literally | |
|---|---|---|
| pos.v cat.abstract describability-by; | is | |
| pos.n cat.science canis-familiaris; | dog | |
| pos.adj cat.abstract intelligence; +dir +opn | smart | |
| pos.v cat.movement throw/catch; past +dir | threw | |
| pos.n cat.y relativizer; rel.n | [noun relativizer] | |
| pos.n cat.object; | object | |
| pos.adj cat.adjective roundness; rel.tt +dir | round |
the dog that threw the ball is smart
dog [which threw round object] is smart
This is a really awkward tree, but two relative cases are enough to handle it. The noun relativizer would modify "dog" if unmarked, so the skip-level case is used. "Round" would modify the relativizer if unmarked, so two spots are skipped to modify "object" instead.
stateDiagram-v2 is: v.describability-by dog: n.*canis-familiaris* smart: adj.intelligence (direction=+1, opinion=+1) threw: v.throw/catch (tense=-1, direction=+1) nr: n.relativizer object: n.object round: adj.roundness (direction=+1) state gap1 <<choice>> state gap2 <<choice>> is --> dog is --> smart dog --> threw dog --> gap1 threw --> nr threw --> object object --> round object --> gap2
| Gloss | Literally | |
|---|---|---|
| pos.v cat.abstract describability-by; | is | |
| pos.v cat.y relativizer; | [verb relativizer] | |
| pos.adj cat.adjective; -opn | bad | |
| pos.v cat.movement throw/catch; +dir | throw | |
| pos.n cat.object person; rel.nt | person |
throwing people is bad
[throw person] is badness
Only new thing to note is the use of the bare adjective category as a word of its own. This is used for words like "bad" or "intense" where the meaning is conveyed entirely through the suffixes for opinion and intensity, respectively. "Person" would modify the relativizer if unmarked, so it needs to skip a line and a spot to modify "throw".
stateDiagram-v2 is: v.describability-by vr: v.relativizer bad: adj.adjective (opinion=-1) throw: v.throw/catch (direction=+1) people: n.person state gap1 <<choice>> state gap2 <<choice>> is --> vr is --> bad vr --> throw vr --> gap1 throw --> gap2 throw --> people
| Gloss | Literally | |
|---|---|---|
| pos.conj cat.y and; | and | |
| pos.v cat.abstract describability-by; ++cert | definitely are | |
| pos.v cat.abstract possession; ++cert | definitely have | |
| pos.n cat.science homo-sapiens; plural | humans | |
| pos.adj cat.TODO free/TODO; | free | |
| pos.n cat.object 3p(1st); | they | |
| pos.conj cat.y modifier; | [modifier] | |
| pos.v cat.science live-birth; | born | |
| pos.conj cat.y and; rel.t | and | |
| pos.adj cat.abstract equality; | equal | |
| pos.n cat.y relativizer; rel.t | [relativizer] | |
| pos.n cat.TODO dignity/TODO; | dignity | |
| pos.n cat.TODO right/TODO; plural | rights |
Second sentence:
| Gloss | Literally | |
|---|---|---|
| pos.conj cat.y and; | and | |
| pos.v cat.abstract possession; ++cert | definitely have | |
| pos.conj cat.y modifier; | [modifier] | |
| pos.n cat.object 3p(1st); | they | |
| pos.conj cat.y and; | and | |
| pos.v cat.TODO act/TODO; future dir×1 | should act | |
| pos.n cat.object 0p; | [passivizer] | |
| pos.n cat.abstract logic/reason; rel.tt | reason | |
| pos.n cat.TODO conscience/TODO; | conscience | |
| pos.conj cat.y joiner; | [joiner] | |
| pos.adv cat.TODO sibling/TODO; | sibling-ly | |
| pos.n cat.object 3p(1st); abs.rlll | they | |
| pos.n cat.object 3p(1st); !dir | themselves |
All human beings are born free and equal in dignity and rights. They are endowed with reason and conscience and should act towards one another in a spirit of brotherhood.
humans [which are born] are free, and they have equal (dignity and rights). they have reason and conscience, and they are requested to act on themselves sibling-ly
stateDiagram-v2 and1: conj.and are1: v.describability-by (certainty=+1.5) have1: v.possession (certainty=+1.5) humans: n._homo-sapiens_ (plural) free: adj.(free) they1: n.3p1 modifier1: conj.modifier born: v.reproduction and2: conj.and equal: adj.equality nr: n.relativizer dignity: n.(dignity) rights: n.(rights) (plural) and3: conj.and have2: v.possession (certainty=+1.5) modifier2: conj.modifier they2: n.3p1 and4: conj.and act: v.(act) (tense=+1, mood=directive×1) passive: n.0p reason: n.reason conscience: n.(conscience) joiner: conj.joiner brotherly: adv.(sibling) they3: n.3p1 themselves: n.3p1 (direction=reversed) state gap1 <<choice>> state gap2 <<choice>> [*] --> and1 and1 --> are1 and1 --> have1 are1 --> humans are1 --> free have1 --> they1 have1 --> modifier1 humans --> born humans --> gap1 modifier1 --> and2 modifier1 --> equal born --> gap2 born --> nr and2 --> dignity and2 --> rights [*] --> and3 and3 --> have2 and3 --> modifier2 have2 --> they2 have2 --> and4 modifier2 --> act modifier2 --> passive and4 --> reason and4 --> conscience act --> joiner act --> brotherly joiner --> they3 joiner --> themselves
Also a tree more complicated than the damn UN human rights declaration...
| Gloss | Literally | |
|---|---|---|
| pos.v cat.abstract identicality-to; present +cert | is now known to be | |
| pos.n cat.abstract name-OliviaRodrigo; | Olivia Rodrigo | |
| pos.conj cat.y modifier; | [modifier] | |
| pos.conj cat.y selector; rel.tt | such that | |
| pos.adj cat.abstract ordinal-1dozenal; | first | |
| pos.n cat.object person; | person | |
| pos.v cat.motion point-in-time; | was at | |
| pos.v cat.TODO debut/TODO; rel.n past | debuted | |
| pos.adj cat.TODO female/TODO; | female | |
| pos.v cat.y relativizer; | [relativizer] | |
| pos.n cat.science time; | time | |
| pos.n cat.y relativizer; | [relativizer] | |
| pos.conj cat.y selector; | such that | |
| pos.v cat.abstract compared-or-equal; rel.tt -dir | being at lowest | |
| pos.v cat.y relativizer; rel.t | [relativizer] | |
| pos.n cat.TODO song/TODO; rel.ntt plural | songs | |
| pos.v cat.motion point-in-time; | was at | |
| pos.n cat.object 3p(rlllrl); | them (the songs) | |
| pos.n cat.object 3p(rlllrrllr); | them (Hot 100's 10th song) | |
| pos.v cat.TODO debut/TODO; past | having debuted | |
| pos.v cat.abstract compared-or-equal; rel.n -dir | are at latest | |
| pos.v cat.y relativizer; rel.t | [relativizer] | |
| pos.v cat.y relativizer; | [relativizer] | |
| pos.n cat.object 3p(rlllrl); rel.tttt | them (the songs) | |
| pos.n cat.y relativizer; rel.n | [relativizer] | |
| pos.n cat.TODO song/TODO; | song | |
| pos.v cat.abstract compared-or-equal; -dir | being at lowest | |
| pos.v cat.abstract compared-or-equal; rel.t +dir | at least | |
| pos.n cat.object 3p(l); rel.n | her | |
| pos.adj cat.abstract ordinal-Adozenal; | 10th | |
| pos.n cat.object 3p(rlllrl); | them (the songs) | |
| pos.n cat.TODO song/TODO; | song | |
| pos.n cat.science time; | time | |
| pos.n cat.science week; | week | |
| pos.n cat.abstract name-Hot100; rel.tttttt | Hot 100 | |
| pos.adj cat.abstract ordinal-Adozenal; | 10th | |
| pos.adj cat.abstract number-1dozenal; rel.tt | one |
Olivia Rodrigo becomes the first woman in history to debut her first ten top 10 Hot 100 hits in the top 10.
OliviaRodrigo is now known to be the first female person [which debuted songs [which are at-or-before her 10th song] such that [[them (the songs) being at-or-above the Hot100's 10th song] was at [time at-least one week]]] such that [[them (the songs) being at-or-above it (the Hot100's 10th song)] was at [them (the songs) having debuted]'s time]
Possibly the most powerful demonstration of the unambiguous-ness of this tree-based syntax, and also why it's completely unnatural and to a large extent hilariously impractical. This is the first demonstration of the "such that" conjunction, which in this case selects the person whose songs debuted in the top 10, and the songs that were in the top 10 any week. This is also the first real demonstration of the name transliteration system; "Hot 100" is treated as the name "Hot One Hundred" and thus gets a really long transliteration, which is not helped by its extremely awkward place in the tree, necessitating a lot of case suffixes.
stateDiagram-v2
becomes: v.identicality-to (tense=0, certainty=+1)
olivia: n.name-OliviaRodrigo
becomes_modifier: conj.modifier
modifier_selector: conj.selector
first: adj.ordinal-1<sub>dozenal</sub>
woman: n.person
modifier_at: v.point-in-time
woman_debuted: v.(debut) (tense=-1)
female: d.(female)
modifier_vr: v.relativizer
debuted_time: n.time
woman_debuted_nr: n.relativizer
woman_selector: conj.selector
modifier_leq: v.less-than-or-equal-to
state modifier_gap <<choice>>
time_vr: v.relativizer
state time_gap <<choice>>
songs: n.(song) (count=plural)
woman_at: v.point-in-time
modifier_they: n.3p[the songs]
it: n.3p[hot 100's 10th]
time_debuted: v.(debut) (tense=-1)
state time_vr_gap <<choice>>
songs_leq: v.less-than-or-equal-to
state songs_gap <<choice>>
woman_leq_vr: v.relativizer
woman_week_vr: v.relativizer
time_they: n.3p[the songs]
state time_debuted_gap <<choice>>
songs_nr: n.relativizer
songs_song: n.(song)
woman_leq: v.less-than-or-equal-to
state woman_gap <<choice>>
geq: v.greater-than-or-equal-to
state week_vr_gap <<choice>>
her: n.3p[her]
songs_tenth: adj.ordinal-A<sub>dozenal</sub>
woman_they: n.3p[the songs]
woman_song: n.(song)
geq_time: n.time
week: n.week
hot100s: n.name-Hot100
woman_tenth: adj.ordinal-A<sub>dozenal</sub>
one: adj.number-1
state week_gap <<choice>>
becomes --> olivia
becomes --> becomes_modifier
becomes_modifier --> modifier_selector
becomes_modifier --> first
modifier_selector --> woman
modifier_selector --> modifier_at
woman --> woman_debuted
woman --> female
modifier_at --> modifier_vr
modifier_at --> debuted_time
woman_debuted --> woman_debuted_nr
woman_debuted --> woman_selector
modifier_vr --> modifier_leq
modifier_vr --> modifier_gap
debuted_time --> time_vr
debuted_time --> time_gap
woman_selector --> songs
woman_selector --> woman_at
modifier_leq --> modifier_they
modifier_leq --> it
time_vr --> time_debuted
time_vr --> time_vr_gap
songs --> songs_leq
songs --> songs_gap
woman_at --> woman_leq_vr
woman_at --> woman_week_vr
time_debuted --> time_they
time_debuted --> time_debuted_gap
songs_leq --> songs_nr
songs_leq --> songs_song
woman_leq_vr --> woman_leq
woman_leq_vr --> woman_gap
woman_week_vr --> geq
woman_week_vr --> week_vr_gap
songs_song --> her
songs_song --> songs_tenth
woman_leq --> woman_they
woman_leq --> woman_song
geq --> geq_time
geq --> week
woman_song --> hot100s
woman_song --> woman_tenth
week --> one
week --> week_gap
| Gloss | Literally | |
|---|---|---|
| pos.v cat.abstract anticipation; +opn | hope | |
| pos.n cat.object 1p; | I | |
| pos.v cat.y relativizer; | [verb relativizer] | |
| pos.v cat.abstract describability-by; rel.tt | is | |
| pos.n cat.science nighttime; rel.n | nighttime | |
| pos.adj cat.adjective; +opn | good | |
| pos.n cat.object 2p; | your |
I wish you a good night
I hope your night is good
The implied meaning would be "I hope you have a good night", but the English "have" in this case is not really possession, hence the literal meaning above. If unmarked, "nighttime" would modify the relativizer, so it skips to the next level. "your" requires no markings; its position is the next legal spot (the sequence cannot jump back up a level).
stateDiagram-v2 hope: v.anticipate (opinion=+1) I: n.1p vr: v.relativizer is: v.describability-by night: n.nighttime good: adj.adjective (opinion=+1) your: n.2p state gap1 <<choice>> state gap2 <<choice>> hope --> I hope --> vr vr --> is vr --> gap1 is --> night is --> good night --> your night --> gap2
| Gloss | Literally | |
|---|---|---|
| pos.v cat.abstract equals; gnomic | equals | |
| pos.v cat.y relativizer; | [verb relativizer] | |
| pos.n cat.abstract 1; -dir | -1 | |
| pos.v cat.abstract exponent; +dir | exponentiate | |
| pos.n cat.abstract e; rel.n | e | |
| pos.v cat.y relativizer; | [verb relativizer] | |
| pos.v cat.abstract multiplication; rel.tt +dir | multiply | |
| pos.n cat.abstract π; rel.n | π | |
| pos.n cat.abstract i; | i |
eπi = -1
[e exponentiate [π multiply i]] always equals -1
N.B. the use of gnomic tense on "equals". As a reminder, verb expressions on mathematical operations mean their computed result. This tree requires no absolute cases, but might be more understandable with them... "e" would modify the first relativizer if unmarked, so it skips to the next level to modify "exponentiate"; "multiply" would modify "e" if unmarked, so it skips two spots to modify the second relativizer; and "π" would modify the second relativizer if unmarked, so it skips to the next level (skipping one spot would also work) to modify "multiply".
stateDiagram-v2 equals: v.equals (tense=gnomic) vr1: v.relativizer neg1: n.1 (direction=-1) exponentiate: v.exponent (direction=+1) e: n.*e* vr2: v.relativizer multiply: v.multiplication (direction=+1) pi: n.*π* i: n.*i* state gap1 <<choice>> state gap2 <<choice>> equals --> vr1 equals --> neg1 vr1 --> exponentiate vr1 --> gap1 exponentiate --> e exponentiate --> vr2 vr2 --> multiply vr2 --> gap2 multiply --> pi multiply --> i
| Gloss | Literally | |
|---|---|---|
| pos.v cat.abstract identicality-to; | is | |
| pos.n cat.object what; | what | |
| pos.n cat.abstract logic/reason; | reason | |
| pos.v cat.y relativizer; rel.tt | [verb relativizer] | |
| pos.v cat.motion vertical; rel.n -int +dir | are above | |
| pos.n cat.object thing; pl | things | |
| pos.n cat.object floor; | floor | |
| pos.n cat.object 2p; | your | |
| pos.n cat.object container; rel.t | container's | |
| pos.n cat.object person; rel.n pl | people's | |
| pos.adj cat.abstract nighttime; | nighttime |
why are your things on the bedroom floor?
what is [your things are above people's nighttime container's floor]'s reason?
Remember that relative direction words, used as verbs, are copulas with prepositions. You know the drill with the cases, except "vertical" actually can take either relative case (but not neither): unmarked, it would modify "reason"; relative-left could not modify "reason"; and relative-right would be redundant. Also, "people's" would modify "floor" if unmarked, "your" with relative-left, and the gap next to "your" with relative-right, so absolute case is necessary to place it correctly. Since it does not use the plucker case, "nighttime" can follow it as normal. Lacking a word for "bedroom", we use "people's nighttime container".
stateDiagram-v2 is: v.identicality-to what: n.what reason: n.logic/reason vr: v.relativizer vertical: v.vertical (intensity=-1, direction=+1) things: n.thing (plural) floor: n.floor your: n.2p container: n.container people: n.person (plural) nighttime: n.nighttime state gap1 <<choice>> state gap2 <<choice>> state gap3 <<choice>> state gap4 <<choice>> is --> what is --> reason reason --> vr reason --> gap1 vr --> vertical vr --> gap2 vertical --> things vertical --> floor things --> your things --> gap3 floor --> container floor --> gap4 container --> people container --> nighttime