Philosophy of Language

The first people who pondered about how meaning comes from words were actually not linguists, but philosophers! Some of the ideas presented by them are now core concepts in semantics.

The ancient Greek philosopher Plato believed that a word represents a perfect abstract concept. For example, the word “dog” represents some idea called “dog” that doesn’t exist in the real world. All instances of a dog that you actually see are just imperfect imitations of that concept. Plato also thought that individual phonemes had some universal, objective, inherent meaning to them, but as you know, this is false, because sound has nothing to do with meaning. This is why Plato isn’t the most trustworthy source, but you can still take that first theory into consideration if you want.

Compositionality

A major concept in semantics is the Principle of Compositionality. Basically, since there are infinite possible meanings in the world but you can’t have a brand new word for EVERY single new concept due to the finite amount of mental capacity you have, more complex meanings must be derived from simpler ones.

Of course, if you’re going to use a concept very often, and it’s tedious to describe it using many words, it can either shorten or take a loanword.

For example, English took “déja vu” from French, which literally translates to “already seen”, which, in grammatically correct English (for most people’s internal grammar), would have to be expressed as “the feeling of having experienced something before” if not for this loanword. This is obviously much more concise.

Words can also shorten. The full name of “soccer” originated from “association football” (which obviously no one wants to say every time), so that became “assoc”, and then “soccer”.

However, these cases don’t take away from the main point that meanings as a whole are derived from smaller parts - that’s how you understand this sentence, for example. Syntax might allow you to arrange these meanings in the correct way, but compositional semantics allows you to get the overall idea as to what the sentence is actually saying. If you understand each smaller part, then you will understand the whole sentence, even if you haven’t seen this specific syntactical structure before.

Hyponyms and Hypernyms

Now, let’s get into how words relate to each other in terms of how specific they are. A hyponym is a more specific meaning, and a hypernym is more general. So, “cat” is a hyponym of “animal”, and “animal” is a hypernym of “cat”.

To be precise, the hyponym is a subset of the hypernym. This is why every cat is an animal, but not every animal is a cat.

The same concept of unions and intersections from set theory also applies here. “green cat” is just the intersection of anything that is a cat and anything that is green.

You could represent the sets of everything that words or phrases refer to and how they interact using Venn Diagrams, but this stuff is mostly just common sense, not some deep concept in linguistics. There is a NACLO problem on this.

Negations

One problem in semantics is about how negation works. You might think it’s relatively straightforward, until you realize there’s actually not a single way to “negate” something.

Imagine we have a spectrum (with integer values for simplicity) ranging from -10 (cold) to 10 (hot), and we wish to find the numerical value of “not hot”.

If you do computer science or logic, you might think of negation as the not/! operator, that switches a boolean. You might have a variable for the temperature, and “hot” means “temperature == 10”. With this logic, “not hot” means “temperature != 10”, which means it is any number from -10 to 9. This is the same line of reasoning from set theory, where negation might be the complement of a set (“hot” is a set with a single element, 10), so “not hot” means anything but 10.

However, “negate” literally means to multiply by -1, that’s why if you negate 3, you get -3, not every number but 3. So, the traditional view might say “not hot” is exactly “cold”, or “-10”.

Maybe “hot” just means anything that is leaning towards 10 (so it’s more hot than cold), so “not hot” is all the negative numbers.

You must also consider the pragmatic perspective (future blog post). Why would someone say “not hot” as opposed to “cold”? Depending on their intention, the range of what it represents on the spectrum can vary a lot.

If you think this is just a silly thought experiment, think again. One focus of semantics is to find out how languages convey negation. Here’s a more practical example of an English sentence. “I can not do it” could either mean “I am incapable of doing it”, or it could mean “I am capable of not doing it”. You can probably see the difference yourself.

Questions

There are actually a few different types of questions, if you think about it.

The first is a question with a binary yes or no answer, which would usually start with “is/are” or “do/does”, like “do you eat food” or “is the sky blue”.

The second is a question where there is a set of possible answers, possibly of infinite size, and your answer is a subset of that (which can be a single element), like “where do you live” or “who are all in your class”, but even something with a really long answer like “what is the meaning of life”. Semantically, the first type can be thought of as a special case of this type.

Then, there are questions where you list all the options, like “what do you want, tea or coffee”, which assumes you will pick one of them.

Time

Another topic in semantics is how languages express time through tense and aspect, as well as time words. If you want to mark when some verb took place, different languages mark the boundaries differently.

• English has past, present, and future, obviously, but it also accounts for whether something happens and it’s completed, or it’s reoccurring, or it’s completed after reoccurring, or it’s just general.

• Thai doesn’t require that you distinguish tense or aspect, especially if you have context surrounding it.

• Zulu has an extra tense, for distinguishing recent and distant past, but it’s also asymmetric because it only has a single future tense.

• Hindi has something weird, where “yesterday” and “tomorrow” have the same word, “kal”.

All this goes to show that distinguishing events based on time can work very differently based on the language.

There’s also a joke in Arthur that goes like this:

Mom: “You can stay up when you’re Arthur’s age, D.W.”

D.W.: “But I’ll never be Arthur’s age. He’s always going to be three years older than me!”

This is an interesting case of semantic ambiguity with time. I’m gonna use a bit of math (to foreshadow formal semantics, which is later) to formalize this, although you subconsciously get the joke because it’s common sense, and so is the math. Basically, let be the time right now, be Arthur’s age at a moment in time, to be D.W.’s age at a moment in time, and be their age gap. Their mom means , but D.W. thinks it means for some , which is impossible because for all .

Kinship

One more interesting observation is that languages can distinguish words for family members differently. You may or may not have realized this problem, but English’s inventory for family members is kind of limited for relatively prominent stuff.

“Uncle” and “aunt”, for example, can mean both someone who shares a very recent common ancestor with you (their parents are the same as your grandparents) or it can mean someone who was married in to your family. Also, it doesn’t encode whether they are your father or your mother’s siblings / sibling in laws.

Tamil has a LOT of distinctions, meanwhile. Its vocabulary for “uncle” and “aunt” encodes for additional features, such as whether they are an older or younger sibling, whether they are a blood relative or not, etc.

In this NACLO problem, you see just how different other languages express kinship.

Number

A final note on how different languages perceive meanings is for number. As you know, English counts numbers using base 10 (decimal numbers). However, different languages use other bases, though they are less rare.

The most common example is French. Although it mostly uses base 10, there are still remnants of vigesimal counting (base 20) from the previous Celtic languages in modern-day France before Latin arrived, like Gaulish (if you’re interested, Asterix and Obelix is all about the Gauls resisting the Romans). To observe this, look at these numbers:

• 19: dix-neuf (this is base 10, literally “ten nine”, similar to how English “nineteen” is connected to “nine ten”)
• 79: soixante dix-neuf (literally “sixty nineteen”)
• 80: quatre-vingt (literally “four twenty”, instead of English “eighty”, connected to “eight ten”, very vigesimal)
• 99: quatre-vingt dix-neuf (literally “four twenty nineteen”, this is full-on base 20)

For larger digit numbers, it goes back to base 10 (hundreds, thousands, etc), and base 20 is only used for the last two digits sometimes.

Base 10 likely originated because people have 10 fingers to count, so base 20 means they used their toes to count as well.

There are other bases too (such as base 60 from the Babylonians, which is where we get 60 in time and angles from), but they are much more uncommon. Even base 20 is rarely seen anymore.

Semantic Drift

Semantic drift is when the meaning of a word shifts over time. Looking at some common examples might illustrate this better.

Mathematical Representation

One way for linguists to avoid ambiguity is to represent stuff using mathematical notation. Note in advance that most of this is common sense.

For example, take the “I can not do it” example. If we use “¬” to mean negation (as in flipping a boolean value), then the two meanings can be represented as can(¬do(x)) or ¬can(do(x)). Modal verbs like “can” in this case are kind of like functions. Here, x is a variable that can stand for any element that we’re interested in, and it behaves like the parameter for the inner function.

Conclusion

Now that you know how humans traditionally understand meanings, let’s learn about how machines understand them. Stay tuned for part 2!

Further Information

• Crash Course Linguistics Episode 5: Semantics

• MIT OCW Introduction to Linguistics: Semantics especially for formal and compositional semantics

• A Short Introduction to Semantics

• Gottlob Frege

• Ludwig Wittgenstein

• Truth-Conditional Semantics

• Etymology of “bear” from nardi

• Sufficient Conditions for Counterfactual Transitivity and Antecedent Strengthening more in depth for formal logic

• The Arthur joke is from this episode

Craftic

“Craftic” is an exonym. The endonym is this:

satatatatatabuloqutabuloqoquloqutatabuloqutabulqoqoqutatatatabulqutabuloqoquloqutatabuloqutabuloqoqoqoqutabutatatabuloqutabuloqo quloqoqoqutatatatatatatabuloqutabuloqoquloqutatabuloqutabuloqoqoqutatatatabuloqutabuloqoquloqutatabuloqutabuloqoqoqoqutabutatata buloqutabuloqoquloqoqoqutatatatatabuloqutabuloqoquloqutatabuloqutabuloqoqoqutatatatabuloqutabuloqoqulqutatabuloqutabuloqoqoqoqoqe

Conclusion

Please feel free to roast Craftic in the comments.

Programming languages

What about programming languages? They allow people to directly communicate with computers (besides speaking in English to LLMs, which some view as a 5th generation programming language). You can tell the computer how to do a sorting algorithm (though you must give it every single detail, which is a constraint not really present in natural languages), but you can’t really ask it how the weather is, while using, say, Python. However, a computer doesn’t really communicate back to you, apart from maybe the program’s output (which still isn’t in that programming language), so it’s not really a language in the same sense as a natural language. It’s also kind of weird when sometimes, you’re telling the computer how to interact with another user. I think most people would agree that programming languages are, in some ways, languages.

Animals

And what about when a dog barks for different emotions, like if it doesn’t recognize someone or if it’s hungry? You might argue that it’s not, because the barking just points to whatever is going on, so the communication is dependent on whether the thing being talked about is physically present, which is not the point of language. However, barking could just be a very limited language, similar to how programming languages are also limited.

DNA and more

Would any sort of code also be a compiler for a language? For example, you could think of the genetic code as a way to translate every three nucleotides of DNA to a protein, and in that sense, DNA is almost like a programming language because it dictates what proteins to make. I’ll probably write a blog post about this in more detail in the future. There’s even a NACLO problem, Sk8 Parsr, about a “language” used to represent a video game.

How about what makes different languages?

The introduction of the book “The Art of Language Invention” by David J. Peterson goes over the different types of languages in a lot more depth. For the purposes of this blog post, I’m going to stick to natlangs, because that’s where most of the tension is (there isn’t much physical hostility between C and C++ users or anything).

Just getting a baseline definition of what a language is already causes so much disagreement, just wait until you argue about whether languages are distinct or not, which is what we’re going to talk about for the rest of this blog post.

Mutual Intelligibility

Usually, two languages are said to be the same language if they are mutually intelligible, which means speakers of one language can understand speakers of the other language for the most part. Since American and British English are similar enough to be mostly understood by each other, they’re considered the same language.

However, this has some problems. How intelligible is intelligible enough for two languages to be the same, and wouldn’t making such a line be subjective and arbitrary? Also, what intelligibility score would you use?

Role of Politics, Nationalism, and Standardization

Lots of times, countries have the need for a national identity so that they will remain unified. A really strong way to do this is to make all the citizens feel like they have the same culture, and that other countries have different cultures, and a really strong indicator of culture is language. So, if a country says “we are the sole speakers of this language, and this other country speaks a separate language”, then their national identity will likely be much stronger.

One example of this is how Hindi and Urdu are considered separate languages today. When India and Pakistan split, they both wanted to have a secondary national language apart from English. Hindi and Urdu are both just varieties of the larger Hindustani dialect continuum (it’s sometimes considered a single language too - I know this entire blog post is about how defining what makes a language distinct is very hard, but their spoken forms are much closer than, say, Canadian and Senegalese French, which are considered a single language).

Hindustani as a dialect continuum existed before the partition of India and Pakistan and was spread out on both sides of the modern border. So, if you ignore politics, there shouldn’t be any reason to say that the language spoken one millimeter into the Indian side is the same language as the one spoken way way way inland, but it’s a different language from the one spoken one millimeter into the Pakistani side.

Hindi and Urdu are basically mutually intelligible colloquially, but their formal written forms are very different - for one, they use completely different orthographies, so the speaker of one can’t read a single word of the other.

Standardization allows for national languages to make themselves distinct. Formal Hindi, which is emphasized in Indian schools, takes a lot more modern borrowings from Sanskrit vocabulary, while formal Urdu, which is emphasized in Pakistani schools, has a lot more Persian and Arabic loanwords. So, while speakers of either language can understand each other when speaking colloquially, their respective governments tried to make the standard forms diverge more.

Idiolects and Code-Switching

Right now, we’ve seen how languages can differ through space and time. However, it can also vary at an individual level too.

My own solution

So, we’ve seen the complications of defining and distinguishing languages, and it’s still not entirely agreed on by linguists. So, let’s see how I personally solve this dillema.

I think that everyone has their own languages that just overlap similarly enough to be able to communicate. There’s no point in asking if my English is the same as your English, because the answer will always be no. Even if we understand each other perfectly, because our differing rules won’t necessasrily take away from understanding, we both may still have a different idea of what certain words refer to exactly. This distorts the meaning by a nonzero amount, but usually the meaning being distorted isn’t the main point being made, so it doesn’t matter. Defining English is like defining a game, because it could be a family resemblance (for more information, read my upcoming semantics blog) - instead of a single unifying feature, it’s just a network of languages that have close connections to some of the others, but not all.

Your own language is also continuously changing - for example, you can say the same word over and over again, and there will always be very slight phonetic differences, since frequency is a real number, not a discrete quantity like rules, so it’s nearly impossible to replicate exactly. Obviously, this is a terrible and nitpicky example. A better example is how your language always gets shaped by other people. When I was new to Discord, I used to always use the actual laughing emoji to indicate that something was funny, but then I saw that others used the skull emoji in that same context, so I started to use that instead.

Mutual intelligibility is relative. Even though that there’s not a specific metric that can perfectly quantify it, people can generally tell how well they understand other languages. It’s definitely not a binary - even though you might understand 0% or 100% of some text, these are just the extreme cases.

The specific language that someone speaks is a function of them, their audience, and the occasion. Obviously, a language can’t just be based on a single person, because the point of it is to communicate with someone else. Even if you speak multiple “different” languages (as in, not thought of as English, and very little intelligibility, such as French), your brain still can choose this - you’ll only speak French to another person who knows French, but you probably won’t speak it to a random person in the USA who may or may not know French. And maybe if in the exact same occasion and audience, you could speak in two different ways (like speaking to someone in your French class in English, because they can converse with you in either), the way of choosing this is more conscious than subconscious, but maybe you can consider the conscious decision as part of the occasion too.

If everyone speaks multiple languages, then how do you define multilingualism? I’d say that for most people who only speak a variety of English, the differences are too negligible to say that you speak 50 languages. When accounting for code switching, you should only count changes that alone are unintelligible. So, the total languages I speak between my sister and my friends would only be 1.001 or something very close to 1, because only a small amount of vocabulary, pronunciation, and grammar is different. Now, if I hypothetically speak only standard English and standard Chinese, that should count as almost 2 languages, maybe 1.998, because Chinese and English have almost no vocabulary in common (shared word order shouldn’t really count for intelligibility if none of the vocabluary or genetic relationship is common), apart from the very few loanwords that exist. If I speak hypothetically only standard English and standard German, that would maybe be 1.7 languages or something like that.

There must in theory be some metric to measure mutual intelligibility that can fit this criteria, even if it’s hard to actually compute. I think this really is the problem with distinguishing languages. If there is a real, objective score for saying how different two languages are, then our problem is solved! However, for now, this is still based on vibes, so we can only say that they are not the same language.

Conclusion

As you can see, there are many complications when it comes to defining a language. If you disagree with my solution to this issue (which you likely will), please write your interpretation in the comments, because different opinions will be very cool.

SLIYS

That’s why I was thrilled to learn that every summer, the Ohio State University hosts a program called SLIYS (Summer Linguistics Institute for Youth Scholars) that actually formally teaches you the basics of linguistics. They have two one-week online sessions - SLIYS 1 and SLIYS 2, which are more introductory and more in-depth respectively. You have to take SLIYS 1 in order to be eligible to take SLIYS 2 later on. Sadly, I was only able to take SLIYS 1 this summer, because I had a schedule conflict during SLIYS 2, but I hope to take it next year.

Conclusion

Overall, SLIYS is an extremely unique opportunity that you get in high school to learn and do linguistics, and I’d strongly recommend that you participate in it if you want to learn more about the field.

Thank you to my instructors, Lindon Dedvukaj, Kyler Laycock, Angelica Aviles Bosques, and Ellie Wren-Hardin!

Proto-Languages

So, what is this kind of language that all these words come from? It is called a proto-language, which means it has never been directly observed in speech or writing, but instead was reconstructed by linguists using the comparative method. While its grammar and vocabulary aren’t necessarily 100% correct, because no one knows its exact form, its existence is almost guaranteed since it was able to be fully reconstructed.

In this case, this language is called Proto-Indo-European. It is estimated to have been spoken around 6000 years ago in the Eurasian Steppe.

The name of a language family, which is a group of languages that are all related to each other, usually shares a name with that of the proto-language. For example, the Indo-European language family descends from Proto-Indo-European, and the Dravidian language family descends from Proto-Dravidian.

Proto-languages can also be the ancient, reconstructed ancestor of any group of languages, not just the whole family. For example, the ancestor of all Germanic languages, like English, German, and Swedish, is called Proto-Germanic.

Another strange example is of the Romance languages. Even though we know they are all descended from Latin, there is still a proto-language called Proto-Romance, which is in between the Latin spoken by the elites in the Roman Empire and the modern Romance languages. It’s obtained using the comparative method on all the living Romance languages to find the most recent common ancestor. So, proto-languages can even be spoken after a known, recorded language.

The Comparative Method and Backtracking Sound Changes

I’ve mentioned that the comparative method is how linguists reconstruct proto-languages, but how does it work?

An important fact is that sound changes are regular, so typically, a certain rule like “a [k] sound turns into an [h] sound” will apply to all words in a language, and not just some of them. This is what allows us to backtrack sound changes, which is the main technique used in the comparative method. This, by the way, was one of the sound changes from Grimm’s Law, which I talked about in the previous post.

As a fun note, you can also find out timelines using sound changes. For example, in Arabic, there was a sound change where [p] turned into [f], and this time period is known. Nowadays, since the [p] sound doesn’t exist, speakers might borrow words with that sound but pronounce it like a [b]. So, if an Arabic loanword is pronounced as [b] while other languages pronounce that same word with a [p], then we know that this word was borrowed after the sound change, because if it was borrowed before, then it would be pronounced as an [f] instead. Since Arabic speakers have inhabited Palestine for a long time, they pronounce it as “filastin”, while newer concepts to Arabic speakers, like “pizza”, are pronounced as “bizza”.

Also, the Indo-European languages are usually classified into “centum” (Latin) or “satem” (Avestan), based on the first consonant in their word for “hundred”. The Indo-Iranian, Armenian, and Balto-Slavic languages underwent a sound change where the *ḱ was pronounced as [s]. The Italic, Hellenic, and Celtic languages have the first consonant in “hundred” pronounced like [k], so we know that they split off before that sound change happened (there’s not any known sound change that would have brought the [s] back to the [k], otherwise). The Germanic languages are where we have to apply multiple sound laws. The first consonant in “hundred” (or “Hundert” in German) is pronounced as [h]. There is no law changing [s] to [h] for Germanic languages (but this does exist for Iranian languages). However, Grimm’s Law does bring *k to [h]. Therefore, we can conclude that the Germanic languages split off before the sound change that shaped the satem languages.

Here is a diagram showing how the word for “hundred” evolved through the different Indo-European languages. This is a much smaller diagram, only showing a few selected branches and languages. It also points out some of the notable sound changes.

%%{init: {
  "theme": "base",
  "themeVariables": {
    "fontSize": "60px"
  }
}}%%

graph TD

PIE["PIE: *ḱm̥tóm"]

PIE --> Centum["Centum Languages"]
PIE -->|"*k → s"| Satem["Satem Languages"]

Satem --> PBS["Proto-Balto-Slavic: *śimtas"]
Satem --> PII["Proto-Indo-Iranian: *ćatám"]

PII --> Iranian
Iranian --> Avestan["Avestan: satem"]

PII --> IndoAryan["Indo-Aryan"]
IndoAryan --> Sanskrit["Sanskrit: śatam"]

PBS --> Baltic
PBS --> Slavic

Baltic --> Lithuanian["Lithuanian: šimtas"]
Slavic --> Russian["Russian: sto"]

Centum --> Italic
Centum --> Germanic

Italic --> Latin["Latin: centum"]
Latin -->|"*k → s"| Spanish["Spanish: cien"]

Germanic -->|"*k → h"| PG["Proto-Germanic: *hundą"]
PG --> English["English: hundred"]

%% PIE styling (green root node)
classDef pie fill:#7CFC90,stroke:#1B5E20,stroke-width:4px,color:#000,font-size:26px;

%% Centum (blue branch)
classDef centum fill:#CFE8FF,stroke:#1565C0,stroke-width:4px,color:#000,font-size:26px;

%% Satem (red branch)
classDef satem fill:#FFD6D6,stroke:#C62828,stroke-width:4px,color:#000,font-size:26px;

class PIE pie;

class Centum,Italic,Germanic,Latin,Spanish,PG,English centum;

class Satem,PBS,PII,Iranian,Avestan,IndoAryan,Sanskrit,Baltic,Slavic,Lithuanian,Russian satem;

%% thick links
linkStyle default stroke-width:5px;

Note that the Romance languages, descended from Latin, pronounced it as [s], not [k] - it’s coincidentally the same sound change that caused the centum-satem split, but it happened much later. Additionally, the satem languages don’t necessarily pronounce the first consonant as exactly [s], but it is generally a voiceless fricative in around that area, like [ʃ] for instance.

Some sound changes are much more likely to occur than others. For example, it’s much more likely for a /t/ sound to turn into a /tʃ/ sound if it’s near an /i/ or a /j/ sound, than if it is near an /o/ or an /a/ sound, because of a trend called palatalization. Also, /t/ probably won’t turn into a /ɬ/ near an /i/ or a /j/. This is how the Latin word “leite” turned into the Spanish word “leche”.

Typically, simplifications or reductions won’t be reversed, because that information is gone. This is why the word “eau” in French won’t turn back into “aqua” in Latin, because a lot of information was lost, so if we know that either French or Latin is the ancestor of the other, we can tell that Latin is the ancestor of French. If a sound change causes a sound to be added, it’s most likely due to the language’s phonotactics changing - for example, in Latin, the beginning consonant cluster “st” (like in “studere”, meaning “to study”) was allowed, but in Spanish, it wasn’t, so an “e” was added to the beginning to make it “estudiar”.

Looking for corresponding phonemes cross-linguistically and across many cognates is an important step. For example, if you look across Tamil, Telugu, and Kannada to try an reconstruct Proto-South-Dravidian (a descendant of Proto-Dravidian), you might notice that wherever Telugu and Kannada end in a /u/, Tamil reduces this final vowel and turns it into the null phoneme, /∅/.

Then, you try to figure out which sound change is the most likely to have happened, which kind of feels like a pretty hard puzzle. With enough data, you can reconstruct common vocabulary for the ancestor language without any logical contradictions.

Sometimes there are multiple possible reconstructions. Since they are all valid from the data alone, you need to rely on other tools to determine which is better, like how relatively likely the sound changes are cross-linguistically, or how many exceptions your rules have.

Order of sound changes

If you have multiple sound changes, the order in which they take place matters a lot. For a very simple example, take these two hypothetical sound changes:

Suppose that in Proto-X, the word for “cat” is *zop.

To get that word in the modern language X (zombe), we know there are three sound changes that happened:

1. Final voiceless stops become voiced (zob).
2. Final voiced stops have an “e” added after them (zobe).
3. Vowels before voiced stops have a nasal added right after them (zombe).

Now, see what happens if we put 2, then 3, then 1:

First, no change, because the final consonant isn’t voiced. Second, no change, because there is no vowel before a voiced stop. Third, the final consonant becomes voiced, so the word is “zob”.

Thus, due to the nature of conditionals in sound changes, changing the order of sound changes can lead to different outcomes. In this sense, finding the right order is heavily reliant on logic.

It’s not always true that the order of sound changes matters, if the sound changes are independent of each other and can only build on each other, not mutually interfering. For example, if you start with the single-sound word *ɸ, you can have these sound changes, and all 5040 rearrangements of them will lead to the same resultant word, udʱ:a.

1. fricatives become stops
2. voiceless consonants become voiced
3. unaspirated consonants become aspirated
4. ungeminated consonants become geminated
5. add an “a” after all consonants
6. add a “u” before all consonants
7. bilabial consonants become alveolar

There is a really easy NACLO problem exactly like this called Rewrite me badd, except it is for a real language.

Push/Pull Chains

Sometimes, if a sound change pushes one sound into another existing sound, then that sound will turn into another sound to maintain the distinction, and so on. This is called a push chain.

An example of this is the Great Vowel Shift in English. /e:/ (beet) and /o:/ (boot) sounded more like /i:/ and /u:/, so /i:/ (time) and /u:/ (house) sounded more like /aɪ/ and /aʊ/.

The reverse may also happen. If a sound change turns into another sound that didn’t exist before, then the previous sound is unused, so another sound may turn into that, and so on, and this is called a pull chain.

Common Sound Changes

Here are the most common types of sound changes:

• Assimilation: A sound becomes more like its neighbors, like “octo” in Latin turning into “otto” in Italian (the /k/ became a /t/)
• Dissimilation: A sound tries to contrast with its neighbors more (like saying “February” as “Febyuary”)
• Insertion: A sound must be added to make the word easier to say (like “something” ocassionally having a [p] between the /m/ and /θ/)
• Deletion: A sound disappears (the /k/ in “knight” actually used to be pronounced)
• Metathesis: Two sounds get replaced (like how my sister once said “can we please stop having this conservation” instead of “conversation”)
• Strengthening: A sound becomes more like a consonant (some people pronounce “this” as “dis” because stops are more consonant-like than fricatives)
• Weakening: A sound becomes more like a vowel (Grimm’s law where stops became fricatives)

Analogy and Morphological Change

Sometimes, analogies cause speakers to change a language’s morphology and make it more regular. I’ve seen this happening to my sister. Often, she says “drinked” and “hurted” for past tense instead of “drank” and “hurt”. In fact, relatively less common words are more likely to be regularized by analogy, because speakers are less likely to interact with all the irregularity. This is why you’ll never find my sister saying “eated” or “haved”.

Proving Language Relationships

At first, we don’t know for sure if languages are related or not. One of the most reliable ways to prove that they are related is to try and reconstruct a proto-language including that language, and see if it can be done completely and without much of a stretch.

This isn’t always a simple yes or no. The Niger-Congo family is hypothesized to link the Atlantic-Congo and Mande language families. Although Proto-Niger-Congo has not been reconstructed apart from some vocabulary, the theory is still relatively strongly believed in.

Some people who weren’t quite linguists, such as Nicolaes Witsen and Philip Johan von Strahlenberg, believed that the Turkic, Mongolic, and Tungusic languages (Manchu, the language of the early part of the Qing Dynasty, is a Tungusic language) were all part of the same language family, a hypothetical Altaic family. The philologist Matthias Castrén even went so far as to add the Uralic languages as a separate branch too. The mainstream pro-Altaic view sometimes added Japonic and Koreanic languages (mainly Japanese and Korean respectively, but they have smaller languages too) to the proposed family as well, making it the Macro-Altaic hypothesis.

The basis in this theory was mainly due to similarities in grammar, like how they all had agglutinative morphology and SOV word order. They did have some shared vocabulary that appeared to be basic, like body parts. However, there was simply just not enough data to reconstruct a proto-language. Therefore, the Altaic hypothesis was not proven. Some linguists argue that technically, all languages, even English and Chinese, could be related, but we just have no way of knowing since they have diverged so much.

Sprachbunds

In fact, there is a much more convincing explanation for the similarities between the Altaic languages, and this is that they form a sprachbund instead. A sprachbund, from the German “Sprachbund”, meaning “language alliance”, means that languages that are not necessarily related can influence each other, including both loanwords and grammatical structure, due to their geographical proximity. Sprachbunds typically get closer and closer over time, because of their continued contact, whereas language families actually tend to diverge over time because they spread out. The Altaic languages showed signs of the former, because the early forms of Mongolic, Turkic, and Tungusic languages differed more than they do now, and there is no evidence of them diverging at some point.

It is possible for sprachbunds to consist of related languages. For example, the Balkan sprachbund contains Greek, Bulgarian, Serbain, Albanian, Romanian, Romani, and some dialects of Turkish. Apart from Turkish (which is, and you’ll never guess this, a Turkic language), the others are all Indo-European. The similarities between them (articles as postpositions, evidentiality, shared cases, loanwords/cliques, and a lot more) cannnot be explained because they are Indo-European - that would mean the Romance, Slavic, Hellenic, Albanian, and even Indo-Iranian languages all share a pretty close common ancestor, but that contradicts how ancient the centum-satem split is, and the Balkan languages are on either side of it.

Loanwords

If a language has loanwords from another language, this is a huge piece of evidence that they came into contact at some point. A huge part of English vocabulary is borrowed from French, mostly the fancy big words that aren’t Greek or Latin. It’s not that big of a deal if we already know the history behind this - it’s well known that these loanwords are because of the Norman conquest of England, where French was used as the language of the elite, which explains why the words associated with the elite were French (for farm animal names, the word for the living creature, which the English-speaking commoners interacted with, are Germanic, like “cow” or “lamb”, but the word for the dead creature, which the French-speaking elite ate, were French, like “beef” or “mutton”).

However, if we find loanwords as a result of a historical event that wasn’t well documented or known about, or even from prehistory, we can even reconstruct that event. For example, the Germanic languages have a lot of loanwords (we know these must be loanwords because they don’t have any Indo-European cognates or etymology) from Pre-Indo-European languages (with unrelated languages), especially for concepts that were new to the Indo-Europeans, because they were local to the area that they arrived to. Therefore, we can deduce that the Indo-Europeans encountered Pre-Indo-European speakers when they arrived in that region of Europe.

Conservative Languages

Some people might be surprised about a famous observation in historical linguistics, that Sanskrit is more mutually intelligible with Lithuanian than it is with Hindi, even though Hindi is a direct descendant of Sanskrit, while Lithuanian isn’t even Indo-Iranian.

For example, look at the sentence “your gift is the fire”.

Sanskrit: तव दानं अग्निः अस्ति (tava dānaṃ agniḥ)

Lithuanian: tavo dovana ugnis

Hindi: तुम्हारा उपहार आग है (tumhārā upahār āg hai)

As you can see, the Sanskrit and Lithuanian sentences both have a similar structure, and the vocabulary appears more similar. While Hindi has cognates for “your” and “fire”, they are less recognizeable than the Lithuanian ones. Also, the copula (the word for “is”) is mandatory in Hindi, because it is more analytic. Meanwhile, since Sanskrit and Lithuanian are more synthetic, the parts of speech are built into the words themselves, so the copula is not needed and used more for emphasis (they are asti and yra, respectively). Also, Lithuanian happens to have SVO word order while Sanskrit and Hindi have SOV word order, but Sanskrit and Lithuanian both have flexible word order.

So why is Lithuanian so similar to Sanskrit? It’s because Lithuanian is pretty conservative, or resistant to change.

Sanskrit, being an ancient language, is relatively close to Proto-Indo-European, because it hasn’t had that much time to evolve compared to modern languages. While it was alive, it still was conservative, because it was heavily standardized.

Lithuanian, on the other hand, is still spoken natively to this day. However, the Baltic countries were relatively isolated (since the forests, wetlands, and rivers formed natural barriers) from the rest of Europe and all the conquests that happened that caused language change, so their languages (excluding Estonian, which is Uralic) have preserved many features from Proto-Indo-European, and innovated new features relatively slowly. Because of this, Lithuanian and Sanskrit are both similar to Proto-Indo-European, and therefore similar to each other.

Tamil is another example of a conservative language. It is relatively close to Proto-Dravidian, compared to Telugu and Kannada, which have innovated more. This is why ancient Tamil literature is still understandable to modern Tamil speakers. However, Tamil has huge diglossia, or intelligibility gap, between the formal variety learned in school and spoken on the news, and the colloquial variety spoken on the streets and at home. The formal variety is the one that is more conservative. I only understand the colloquial variety, which is why to me, ancient Tamil literature might as well be written by aliens from Jupiter. I’m going to write a future blog post about languages and dialects, but this is a small taste of that.

Conclusion

Now, we know how proto languages are reconstructed, and how to disprove language family claims. However, some linguists didn’t get the memo that theories about language families must be realistic, so that’s what part 3 is gonna be all about.

Further information

The Arabic example is from this human1011 YouTube short.

I’d recommend the book “Proto” by Laura Spinney if you want a broader picture of how the Indo-European languages spread, using not just linguistics but also archaeology and genetics.

Bracketing and Constituents

Take any complicated sentence in English. For example, take the sentence “The student who the professor whom the dean hired praised left.” This seems so confusing at first. However, we see that the basic sentence is just “the student left”. We can put brackets around the stuff in between, that just describes the student: “The student [who the professor whom the dean hired praised] left”. The “whom the dean hired” just describes the professor, so we can put brackets around that: “The student [who the professor [whom the dean hired] praised] left”.

Each of the bracketed parts, next to the thing it describes, is called a constituent. These are basically units of structure that show some syntactic role.

One way to tell the role that a constituent plays is to replace it with another unit whose role we know. For example, “The student [who the professor whom the dean hired praised]” can be replaced with “The student”, which we know represents the subject. Therefore, every single wrd before “left” is a constituent that represents the subject. Similarly, “left” is a constituent that represents the verb. If you want, you can replace “left” with “ate ice cream”, because this constituent represents what the student did.

Constituents help us figure out what words can be put together. In English, subjects and objects are noun phrases. Pronouns, plurals, and proper nouns can be their own noun phrases, while common nouns need a determiner. So, “Canada” is its own noun phrase, while “a country” is also a noun phrase that is the same syntactic unit. You can say “I go to [Canada]” or “I go to [a country]” but you can’t say “I go to country” or “I go to a Canada” .

%%{init: {
  "theme": "default",
  "themeVariables": {
    "fontSize": "70px",
    "primaryTextColor": "#000000",
    "lineWidth": 3
  }
}}%%

graph TD

S ==> NP 
S ==> VP 
VP ==> V

NP ==> NP1["NP"]
NP1 ==> Det
NP1 ==> N1["N"]

Det ==> The
N1 ==> student

NP ==> MP 
MP ==> Rel
MP ==> NP2["NP"]
MP ==> VP1["VP"]

Rel ==> A["who"]

VP1 ==> V1["V"]

NP3 ==> Pos
Pos ==> his
NP3 ==> N3["N"]
N3 ==> professor

NP2 ==> NP3["NP"]
NP2 ==> MP1

MP1 ==> Rel1["Rel"]
Rel1 ==> B["who"]

MP1 ==> NP4["NP"]
MP1 ==> VP2["VP"]

VP2 ==> V2["V"]

NP4 ==> Det1["Det"]
Det1 ==> the
NP4 ==> N4["N"]
N4 ==> dean

V2 ==> hired
V1 ==> praised
V ==> left

%% -----------------------
%% STYLES
%% -----------------------

classDef sentenceGroup fill:#ffe6cc,stroke:#ff8c00,stroke-width:3px,color:#000;
classDef nounGroup fill:#d9ecff,stroke:#1f77b4,stroke-width:2px,color:#000;
classDef verbGroup fill:#ddffdd,stroke:#2ca02c,stroke-width:2px,color:#000;
classDef mpGroup fill:#fff2cc,stroke:#d4a017,stroke-width:2px,color:#000;
classDef relGroup fill:#ffd6e0,stroke:#e6005c,stroke-width:2px,color:#000;

class S sentenceGroup;

class NP,NP1,NP2,NP3,NP4,N1,N3,N4 nounGroup;

class VP,VP1,VP2,V,V1,V2 verbGroup;

class MP,MP1,Det,Det1,Pos mpGroup;

class Rel,Rel1 relGroup;

%%{init: {
  "theme": "default",
  "themeVariables": {
    "fontSize": "70px",
    "primaryTextColor": "#000000",
    "lineColor": "#000000",
    "lineWidth": 3
  },
  "flowchart": {
    "htmlLabels": true
  }
}}%%

graph TD

S ==> NP
S ==> VP

NP ==> N
N ==> Time

VP ==> V
V ==> flies
VP ==> MP

MP ==> Prep
Prep ==> like
MP ==> NP1["NP"]

NP1 ==> Det
NP1 ==> N1["N"]
Det ==> an
N1 ==> arrow

%% -----------------------
%% STYLES
%% -----------------------

classDef sentenceGroup fill:#ffe6cc,stroke:#ff8c00,stroke-width:3px,color:#000;
classDef nounGroup fill:#d9ecff,stroke:#1f77b4,stroke-width:2px,color:#000;
classDef verbGroup fill:#ddffdd,stroke:#2ca02c,stroke-width:2px,color:#000;
classDef mpGroup fill:#fff2cc,stroke:#d4a017,stroke-width:2px,color:#000;
classDef prepGroup fill:#e6ddff,stroke:#6f42c1,stroke-width:2px,color:#000;

%% -----------------------
%% APPLY CLASSES
%% -----------------------

class S sentenceGroup;

class NP,N,N1,NP1 nounGroup;

class VP,V verbGroup;

class MP,Det mpGroup;

class Prep prepGroup;

%%{init: {
  "theme": "default",
  "themeVariables": {
    "fontSize": "70px",
    "primaryTextColor": "#000000",
    "lineColor": "#000000",
    "lineWidth": 3
  },
  "flowchart": {
    "htmlLabels": true
  }
}}%%

graph TD

S ==> NP
NP ==> M
NP ==> N
M ==> Fruit
N ==> flies

S ==> VP
VP ==> V
V ==> like

VP ==> NP1["NP"]
NP1 ==> Det
Det ==> a
NP1 ==> N1["N"]
N1 ==> banana

%% -----------------------
%% STYLES
%% -----------------------

classDef sentenceGroup fill:#ffe6cc,stroke:#ff8c00,stroke-width:3px,color:#000;
classDef nounGroup fill:#d9ecff,stroke:#1f77b4,stroke-width:2px,color:#000;
classDef verbGroup fill:#ddffdd,stroke:#2ca02c,stroke-width:2px,color:#000;
classDef modGroup fill:#fff2cc,stroke:#d4a017,stroke-width:2px,color:#000;

class S sentenceGroup;

class NP,N,N1,NP1 nounGroup;

class VP,V verbGroup;

class M,Det modGroup;

Possible Sentences

There are a finite amount of rules for how to generate a valid sentence, but an infinite amount of possible sentences (partially thanks to recursion, as you are about to see). You can represent the structure of possible sentences using trees. Note that only the last layer of a tree actually says what each word is. So, “fruit flies like a banana” and “hungry people eat that food” would have their trees looking about the same. Because a language is so complex, it’s hard to write down every specific structure of sentences, so you can only be pretty general.

Scope Ambiguity

Obviously, in spoken language, you don’t have brackets or syntax trees. So, how would you interpret this sentence?

“The dog and the cat that you own fought each other”.

Either this means that you own both the dog and the cat (“[[The dog and the cat] that you own] fought each other”), or your cat fought another dog (“[The dog and [the cat that you own]] fought each other”).

Another example is “I saw the man with a telescope”, which either means the man has a telescope and you saw him, or you used a telescope to see the man.

In general, scope ambiguity is when you can’t tell what constituent is being modified.

Prescriptivists are always like, “commas save lives, people” (“Let’s eat kids” vs “Let’s eat, kids”). However, sentences like these are perfectly acceptable in standard English and the ambiguity can’t just be fixed by adding commas (because that would be considered grammatically incorrect then since prescriptivists say that you can’t put commas in those places). This is just yet another argument for descriptive linguistics - prescriptivists can’t even be consistent with their own objectives, so it’s better to just let language be.

Recursion Introduction

Let’s talk about something that is seemingly completely different, but is actually the heart of what we just did with our nested brackets.

Take the Fibonacci sequence, which you’ve probably heard of before. Let’s look at one of the most common representations of its defitions:

Let and for .

Given only this information, you cannot instantly figure out what is. You have to write it as , and then you have to write as , and so on, until you get down to and . Without the base case, you’d be simplifying forever, because you’d never get it only in terms of numbers.

Now, look at this code snippet in Python:

def reverse(s): # return a String that is the reverse of s
    if len(s) == 1: # base case: if the string has 1 character, 
        return s # it is inherently the reverse of itself, so we can just return it
    return s[-1] + reverse(s[:-1]) # move the last letter to the beginning and find the reverse of the rest

As you can guess from the name of this function, it reverses a string by taking the last letter, the first letter, and the reverse of the middle part in between. As a result, it calls itself. Again, there is a base case, which is that the string being called on has 0 or 1 characters eventually, but it allows us to reverse a string of any length, up to infinity.

Here’s another pattern: Serpenski’s Triangle. You start with an equilateral triangle, then split it into four congruent equilateral triangles, such that the middle part is cut out, and then repeat this for every single equilateral triangle inside, being able to go for an indefinite amount of layers:

The base case of this diagram is that the the triangle has finite size, because the biggest triangle isn’t inside of a bigger one, but you can make triangles as small as you want, that are all just miniature, similar versions to the bigger ones.

There’s one more thing I want to show, to make the pattern evident. Suppose we name the acronym LING to mean LING Is Not Good. Then, a letter of the acronym is the first letter of the acronym itself. So, we have an infinite loop trying to figure out what LING stands for, but we never get there because it keeps on referring to itself, unless we define a base case later on to what LING actually stands for.

This acronym is the same pattern as the Fibonacci sequence, Serpenski’s Triangle, and the reverse function, and it’s called recursion - you define a base case, and then each next step is based on the previous one(s), allowing you to go as far as you want.

Recursion in Syntax

In syntax, recursion is when you can put a constituent inside another constituent of the same level. For example, look at the phrase “the monkey of the friend of the neighbor of the student of the uncle”. This is a noun phrase, because the overall constituent is “the monkey”. Inside of the entire phrase, we have “the monkey of the friend of the neighbor of the student” which is also a noun phrase, and inside of that, we have “the monkey of the friend of the neighbor”, which is also a noun phrase, and so on.

English allows for infinite recursion like this, which is why there is no limit to how long a sentence can be - we can always just recurse one more time. For example, “the uncle” can have “of the person” added to it. We don’t need to explicitly worry about a base case - no matter how long the sentence is, we can always ultimately simplify it down to a single noun (or generally a single constituent or unit), which is the base case. You can also recurse the other direction, like adding “the toy of” before “the monkey”.

More Examples of English Recursion

English doesn’t just need “of” (or equivalently, “’s”) to be able to recurse. Using “of” means a noun phrase is being a recursed. Here are some other examples of English being able to recurse on different constituents.

There can be recursion on full sentences (specifically of the structure where a noun phrase is the subject and it enacts a verb phrase). For example, “I ate food” is a complete sentence. You can also insert this into “You think that I ate food”, which itself is another complete sentence. You can further insert this into “He doesn’t believe that you think that I ate food”, and so on.

The very first sentence we made a tree out of, “The student who the professor whom the dean hired praised left”, is also recursive, because “whom the dean hired” is called a relative clause, and this, describing “professor”, is inside the relative clause “who the professor praised”, which in turn describes “student”.

Prepositional phrases can also be recursed. If you have the phrase “on the table in the house near the window”, this contains the prepositional phrase “on the table in the house”, which contains the prepositional phrase “on the table”.

All this goes to show that English has many mechanisms to recurse different types of constituents.

Embedding

Recursion is just one subset of a larger phenomenon called embedding. Embedding is inserting some constituent into another constituent, regardless of what type of constituent they are, and recursion is when the constituents have the same type.

For example, “the bird flew in the sky” has embedding in the verb phrase “flew in the sky”, because it contains “in the sky”, which is a prepositional phrase.

Recursion in Other Languages

All languages that linguists had encountered up to 2005 had some means to recurse indefinitely. For example, in French, the first recursion example above would be translated as “le singe de l’ami du voisin de l’étudiant de l’oncle”. The word “de” has the same syntactic function that “of” has, which allows the same recursion to work. Note that “du” is just a contraction of “de” and “le”, so it doesn’t do anything different from “de l’”.

You might think that maybe that’s just because English and French are so close, both geographically and linguistically, because English is basically half French anyway (it’s actually 29%, that was an exaggeration).

However, it has nothing to do with proximity, beacuse even Chinese, which is not even in the same language family as English and French and is spoken in an entirely different part of the world, allows for this exact phrase to recurse as “shūshu de xuéshēng de línjū de péngyǒu de hóuzǐ”. Here, “de” (not at all related to the French “de”) is basically the Chinese equivalent of “’s”, so it’s more along the lines of “the uncle’s student’s neighbor’s friend’s monkey”. It just so happens that English allows you to recurse in both directions (because “A’s B” is the same as “the B of A”), while Chinese only allows you to use “’s” and French only allows you to use “of”. This doesn’t matter. The point is, all the languages that linguists encountered so far had some syntactic mechanism to be able to directly translate this phrase.

Pirahã Counterexample

However, the linguist Daniel Everett encountered an indigenous Brazilian language isolate called Pirahã. While you can embed a constituent into another constituent exactly once, to do so indefinitely, you must use multiple sentences. In 2005, Everett published his claim that Pirahã lacks syntactic recursion. For example, instead of saying “the monkey of the friend of the neighbor of the student of the uncle”, you have to say something like this:

The uncle has a student. This student has a neighbor. This neighbor has a friend. This friend has a monkey. This monkey [insert whatever you want to say about the monkey].

In a sense, Pirahã might not have the same idea of recursion as linguists view it, but it’s actually closer to the structure of recursion used in programming. Instead of having all the information in a single unit, you can use the one word (“monkey”) that is the noun phrase in question, that is referenced by a different word (“friend”), and so on, causing you to trace the overall meaning to represent every step all the way to the base case, which is “uncle” in this example. This is pretty similar to calling the a recursive function, like the reverse string function, on a smaller piece, like the middle of the string, until you get enough information, like having a string that has length 0 or 1. The only difference is that there’s not a mandatory base case in Pirahã, and you can stop whenever you want, like at “student”.

Noam Chomsky, the guy who basically invented modern linguistics, thought that all languages had the capacity to recurse, and that it was some universal cognitive trait to humankind as a whole. This is why Chomsky’s supporters find Everett’s claim to be controversial - perhaps Pirahã does have recursion, but it’s in a different sense than what Everett’s notion of recursion was.

Syntax Trees in Programming Languages

Statements from programming languages can also be represented with smaller pieces. Syntax trees for them have to be very precise, because they allow statements to be parsed.

Take the following Python statement:

x = 3 + 5 * 2

This can be represented with the following tree:

graph TD
Assignment ==> x["x"]
Assignment ==> Addition
Addition ==> 3["3"]
Addition ==> Multiplication
Multiplication ==> 5["5"]
Multiplication ==> 2["2"]

There is a very similar recursive structure here, because there is an operator (multiplication) inside of another operator (addition) inside of yet another operator (assignment). If you’ve ever wondered how computers understand order of operations, recursive syntax trees are how - blindly going left to right might cause a mistake, but using a syntax tree is basically foolproof.

The word “syntax” for programming languages is kind of equivalent to the word “grammar” for natural languages, but this is one of the actual instances of “syntax”, the one used for natural languages as an aspect of “grammar”, in programming languages.

I will probably write a future blog post specifically about programming language theory later, but this is an interesting preview into how it uses linguistics tools.

Conclusion

Now that we know how you can break apart sentences into smaller pieces, we can talk about the roles of the smaller pieces themselves! Stay tuned for morphosyntax, including one of the most confusing concepts in linguistics (good luck)!

Proof

Basically, what we seek to prove is that is constant, where is the area swept out by the planet.

.

First, we need to find , a tiny change in the area swept out, in relation to the other tiny changes like in position or time. The planet is moving in an ellipse, so the distance from the center keeps on changing. For a tiny change in position , the distance from the center has barely changed, and we can call this distance . The reason for this is because the new distance is , but since , the change in the radius, is infinitesimal, this is the same as .

is basically the length of the arc made by this tiny change in time, because the curve is zoomed in so much that it looks like a straight line. The area formed by this sector, which is approximately a triangle with two of the side lengths being and , is , where is the angle between and . This is just a basic formula in geometry for the area of a triangle given two sides and the angle between them. You might realize that this is the same as . This is because the area of the parallelogram formed by two vectors is the magnitude of their cross product, and the area of this triangle is half of that.

Because , where is the velocity of the planet, and also is a scalar (which means we can remove it from the magnitude), we can substitute this in to get , so . Similar to , doesn’t change after an infinitesimal change in time , because again, is infinitesimally close to .

Remember that the angular momentum is defined as , where is the mass of the planet. So,

We can substitute this in to get .

Because angular momentum is conserved, and the mass is constant, is constant, which is what we wanted to prove.

Conclusion

Now we know where Kepler’s second law come from, and stay tuned for more physics and astronomy derivations!

Historical context of historical linguistics

This first part is probably way too much information, but for the full context, here you go.

Warning About Cognates

You have to be really careful about cognates, because it could either be that the words really are similar and semantically related, they are false friends (which means that the words just coincidentally sound similar but don’t have a common ancestor), or they are loanwords, which means that one language borrowed the word from another, but this does not imply relatedness or ancestry.

An example of loanwords is when Korean uses “keikeu” for “cake”, but this doesn’t mean that Korean is a Germanic language; instead, it just means that Korean had to borrow from English because they didn’t have a word for “cake” before and they were exposed to Anglophone culture.

False friends are also especially sneaky. If you told a German friend “Ich will dir Gift geben”, which you think means “I want to give you gifts”, they would probably stop being friends with you and even call the authorities on you, because “Gift” in German means “poison”, and has no relation to the English word “gift”.

Sound Changes

To understand the comparative method that will be covered in the next part, we need to first understand sound changes. For example, the word for “water” in Latin is “aqua”, but in French, which is descended from it, it’s “eau”. We know that “eau” and “aqua” are cognates, because “eau” isn’t a loanword and it isn’t gibberish. How could sound changes have caused this to happen?

The main idea is that the /kʷ/ in “aqua” gradually turned into a /w/, since the /k/ sound got weakened, so it sounded more like /awa/. After that, the /w/ sound got weakened as well, and it sounded more like /au/. Finally, the /au/ sound got weakened to /o/, which is how we got “eau” (French also preserves its older spelling, which means at one point it really did used to sound something like “eeyeawoo”).

These sound changes are pretty regular in a single language or language family, and at least have patterns cross-linguistically. For example, it’s more likely for a /tʃ/ to emerge from a /t/ that is near an /i/ or a /j/ than the other way around, because of a trend called palatalization, which is why in Portuguese, the word for “milk” is “leite”, but is pronouned “leiche” (Portuguese preserves historical spelling like French does).

One of the most famous sound changes is Grimm’s law. It states that in Germanic languages, the /p/ sound that is found in other Indo-European languages turned into an /f/ sound, the /t/ sound was turned into a /θ/ sound, and the /k/ sound was turned into an /h/ sound. That’s why in English, we say “father”, “three”, and “heart”, while in the Vatican, Latin speakers say “pater”, “tres”, and “cor”.

There are certain properties about sound changes. They have no exception (a certain rule must apply everywhere in that environment) and they ignore grammar.

Sound changes can also be conditioned or unconditioned. Conditioned means that a sound turns into another sound only in certain environments, while unconditioned means that the sound changes no matter what environment it is in.

To be continued

So we know how people discovered that languages were related. We also know how sound changes and cognates work. How did early linguists use this to figure out Proto-Indo-European, and use this same method for other proto languages? That’s what we will talk about in the next post.

Solution

It seems correct, doesn’t it? The area certainly converges, because after cutting off the corners over and over again, you get the same infinitesimal rectangles that could integrate just like a normal circle to get the same result.

The problem is that the perimeter doesn’t converge. The arc length of a curve from to where and are both functions of is given by

This is NOT the same as .

Are you still not convinced that the perimeter doesn’t converge? Zoom in on an infinitesimal piece of the diagram, which is where the arc length of the circle is basically a line.

In an infinitesimal piece, the limiting process just turns the square into a staircase-like shape, say of -length and -length . On a tiny “step”, the perimeter is just . However, that tiny part of the circle is just a line that goes through the endpoints of the step, so the perimeter is .

You might argue that maybe we should zoom in even more, and the snapshot we took wasn’t the true final result. However, the arc of the circle is already basically a line. By cornering in the square even more, you’re just going to get another line going through a step, and the situation won’t change, so we have, in fact, zoomed in enough. To actually make the square match the circle in its perimeter, we must directly make the horizontal and vertical lines turn into diagonal lines, which changes the perimeter.

Solution

Let the center of the square be the origin of the complex plane. Since we only care about angles, and not sides, we can assume WLOG that is at the point . To rotate a complex number clockwise by an angle , just multiply the number by , so then we end up decreasing the argument (angle measured counterclockwise from the x-axis) by while preserving the magnitude. In this case .

So, the point is at from Euler’s formula (the exponential form is just my shorthand way of remembering how to rotate complex numbers, but you could just go straight to polar form).

Since cosine is an even function and sine is odd, this is the same as: .

This expands to

The angle we want to find is just the direction of the vector from to . So, this is just

, while: .

Essentially, the problem is just boiled down to finding out how to trig bash

There is an identity that: and

I’ll leave it as an exercise to the reader to verify that.

So, if we use this as well as the fact that , the fraction simplifies to

.

Substituting , this simplifies to

Finally, there is an identity that and that .

Again, verifying it is an exercise for the reader.

We now have So or option .

Conclusion

So that’s how to NOT solve a really simple problem! Please don’t do something like this!

Derivatives As Linear Opexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qa1qsxwrators

Do you remember the sum and product rules of single-variable derivatives? 1qsaxwxq

Wait, what??? Differentiation is also a linear operator on functions??? Now you realize how cool generalizing stuff is.

Hold on. Is linear on , for ? The answer, surprisingly, is no. . Linear, in this the context of this blog post, doesn’t necessarily mean the function is a line, but rather that the function behaves like a linear operator, which are typically different things. However, don’t think this form of function isn’t useful outside of 7th grade - when generalized to matrices, these can be very useful in AI.

To be continued

Well, this was not very abstract… yet. In the following parts, we will actually make derivatives more abstract, but this one was just the setup. So, don’t leave just yet.

Multivariable Functions

For multivariable functions, we have many inputs in and one output out, where each input or output is a number. However, one interpretation of a vector is a list of numbers, so one could think of it as a vector in and a scalar out. What this means is that, for a 2D input space, . For any point, or vector, on the 2D plane, there is a coordinate corresponding to that, to form some sort of surface.

Again, what we basically just mean in this case is that a vector has two or more dimensions, and a scalar has just one. If we think of a list of numbers as a vector, then we can do vector operations on it, but if we think of a single number as a vector, doing vector operations on it wouldn’t make a difference.

As for the derivative? It’s a vector, known as the gradient! It is the vector of partial derivatives with respect to each variable. The gradient will always have the same “shape” as the input space, because it also represents the direction of steepest ascent. It’s written as , where is each component in the input.

Vector-Valued Functions

What about a vector output for a scalar input? This could be represented as a parametric equation, and the derivative would also be a vector. An example of this is in physics, with velocity and acceleration, both as a function of time. See the diagram for these in circular motion.

To demonstrate where more abstract derivatives can be used in this case, we can use parametric equations. Let the counterclockwise angle above the horizontal of the particle moving in a circle be , and the radius be . From components, the direction of the position of the particle from the center is . Then, from geometry, since motion is perpendicular to the radius, the horizontal component of velocity (assuming constant speed ) is , and the vertical component is . Given that and , try to prove for yourself that the centripetal acceleration must have magnitude and point towards the center! The full solution is in my blog post about circular motion.

Vector Fields

At this point, we are exiting the more basic types of functions, and finally, matrices come into use here. You may recall that a vector field is a kind of function where for every point (vector) in space, there is an output which is a vector that moves that input somewhere else. As a result, what we can get by reiterating this process can be modeled for something like fluid flow. Maybe you’ve seen some of these diagrams before. Typically, since varying magnitudes get out of hand when drawn on paper, each point has a vector of a fixed length showing just direction, and the magnitudes are portrayed through color, where the “hotter” the color, the longer the magnitude is.

The diagram even looks intuitive. At each point, it tells you where to go next, and by how much. Even if you had no idea about what vector fields are, that’s literally what is looks like.

The derivative is a matrix called the Jacobian. Each row is basically the gradient with respect to the entire input from each component of the output.

If you think of it as looking at each component of the input, the Jacobian is also the derivative of the entire output with respect to each input.

So, if the input space is a vector in and the output space is a vector in , the Jacobian is a matrix with dimensions .

Now, the derivative can be written as for the Jacobian . Now, this looks like a proper matrix multiplication with no scalars involved apart from doing things component-wise.

One cool thing now is that if is a constant matrix, the vector field is just a normal linear transformation of , which is an interesting interpretation of linear transformations.

Conclusion

So far, what we’ve seen is just seeing pretty simple derivatives with a new interpretation. Stay tuned for even more abstract derivatives, and how they relate to AI!

Actual Solution

Assume there are numbers being added up. , since there are at most eight numbers, which means there is one per digit, and at least one number, which is when all the digits are in one number.

Now, we consider the sum mod . Since all numbers have a units digit of as it’s the only possible digit, and they add up to , we get . What this means is that is a multiple of , so it must also be a multiple of , since is a multiple of . Since is not a multiple of , but is a multiple of , then must be a multiple of . The only multiple of between and is . Therefore, we have five numbers being added up.

We know that the maximum possible number is , because is already greater than . If there are or more ’s being added up, then the sum is also over .

We wish to prove that there are not zero ’s either. Assume by contradiction that there actually are zero ’s, so the maximum possible number is just . Now, the maximum possible sum is just which is far less than (this is the maximum because every is the equivalent of adding eleven ’s). Also, to verify that in my head, instead of calculating, I just saw that . Therefore, there must be exactly one being added up.

We find the remaining four numbers must add up to . We can do a similar process to find the number of ’s that must be present. If there are no ’s, then the maximum sum is , not even close to . However, if there are two or more ’s, then the sum is already over . Therefore, there must be exactly one present.

Since there is exactly one and exactly one , and there aren’t any higher possible numbers, the remaining three ’s are used with one per number, filling up the remaining three numbers needed.

Conclusion

Therefore, the final sum is . There are also different ways to rearrange that same equation and keep it true, because it’s (the is to rearrange all the five numbers being added, the is because we don’t care the order the individual ’s are in because it’s all the same, and the is to make the sum on the left hand side or the right hand side).

Morphology

Free and Bound Morphemes

There is also a difference between free and bound morphemes. Free morphemes can exist on their own, while bound morphemes can only exist attached to other morphemes.

For example, look at the word “dogs”. The “s” is a plural marker, but you can’t have a plural marker on its own, so it is bound. Meanwhile, “dog” is free, because it is a word on its own.

Merging Morphemes Subconsciously

Sometimes, a single morpheme could etymologically be derived from two other morphemes, but our brains treat it like a single morpheme due to semantic drifting.

For example, take the word “forgive”. Etymologically, it was derived from “for” and “give”. However, over time, the meaning of “forgive” stopped being derived from “for” and “give” individually. So, people perceive it as a single morpheme, because those historical morphemes don’t contribute to the meaning of “forgive” anymore.

Affixes

Most languages’ morphologies involve affixes, or morphemes being added to words. Here are the main types:

• Prefixes: Go before the word, like “un” in English to mean “not” (unhappy).
• Suffixes: Go after the word, like “s” in English to mean plural (dogs).
• Circumfixes: Go before and after the word, but the parts going on either side don’t mean anything individually, like “ge…t” in German to form the past tense (“kaufen” -> “gekauft”)
• Infixes: Go inside a word, like swear words in some people’s English to make emphasis (abso-[bleep]ing-lutely)

Note

One important thing to note is that trying to classify languages into categories like this isn’t super helpful. Early ideas from linguistics are usually western concepts, because the languages linguists were studying were mostly Eurasian. As a result, these spectrums don’t necessarily account for every single language. Arabic, for example, can’t really be plotted on the 2D grid of the two spectrums, because a consonantal root system is way more complicated. There are many more morphological spectrums (like concatenative and non-concatenative, the latter of which Arabic falls into) that could exist as well, but these are just the most commonly used references ones.

Conclusion

So, now we know how meanings can be arranged within “words” of a language. However, how do these meanings interact? This is what we need syntax for, which will be covered next.

How Sounds Work

At first, the question of “how do sounds work” may seem dumb - you just vibrate your vocal cords, right? However, it’s more complicated than that. When you were a baby, you were as educated as a linguistics major in that you were able to identify how different sounds are made from observing people’s mouths. Now, it’s more difficult to do so, and you may struggle - unless, of course, you’re a baby reading this, and in that case, you should become incredibly famous and win a world record if you haven’t already.

In kindergarten, you may have learned that sounds are classified as vowels and consonants, and that sounds are known as phones.

But what really is the difference between a vowel and a consonant? It’s basically just how much constriction your vocal cords have - vowels have entirely unobstructed airflow, while consonants have noticeable obstruction in the airflow.

Spectrograms

Basically, this is just a graph that records a word being pronounced, where the y axis is frequency and the x axis is time, and both are independent of each other (at a given time, your vocal cords produce a combination of frequencies, which are separated using Fourier analysis). We also want to encode energy as a function of these two, but instead of drawing a z axis, it’s indicated through shading instead. Darker shading means more acoustic energy (or loudness), and lighter shading means less.

Bands of shading are called formants, and they’re mainly for vowels. They are basically the three parameters that vowels take - F1 is high/low, F2 is front/back, and F3 is rounded/unrounded.

Here is the spectrogram for the word “things”:

.

Note that the blank space in the first half isn’t part of the word itself - there was a gap between starting the recording and saying the word.

This blue line measures how fast the vocal cords are vibrating. After the “th”, everything is voiced, which is why it only starts after that first part.

To Be Continued

Now that you know how sounds are produced, let’s find out how linguists write them.

The IPA Review

The International Phonetic Alphabet, or the IPA, is how sounds are represented. Each letter is consistent and makes the same sound all the time, because they are defined using the specific terms we talked about in the Phonetics blog post. To fully understand how some of the examples in this post are pronounced, you might want to check out the IPA chart.

You may have noticed that throughout the last article I’ve used slashes and brackets to refer to sounds. That was not just something random I did because a monkey walked on my keyboard one time and then I stuck with it - this is actually the notation of referencing IPA sounds.

The Difference Between Slashes and Brackets

Why did I use both [] and //? In short, [] is the actual scientific way of making as many distinctions as you want (phonetic transcription), so it doesn’t care about how specific languages perceive sounds. On the other hand, // is when you only care about the distinctions a specific language makes (phonemic transcription), so you’ll typically be less descriptive of how to pronounce that sound.

For example, Tamil doesn’t distinguish between voiced and voiceless consonants, so you could phonemically write the word for monkey as /kuɾaŋku/, even though phonetically, people actually pronounce it as something like [kuɾaŋɡʊ]. However, it doesn’t matter which of those distinctions are used, between [ʊ] and [u] or [k] and [g], since they’re perceived as being the same sound for Tamil speakers.

Allophonic Variation

Phonemes can have different forms, so a single phoneme is more of a category. In the example for “monkey” in Tamil, the phoneme /k/ can mean [k] or [g] depending on the specific word. So, we’d say that the voicing of /k/ is NOT phonemic in Tamil - variations aren’t distinguished in meaning. [k] and [g] are considered allophones - different forms of the same phoneme.

You can write allophones by describing when a certain phoneme varies in a certain environment. So, we get to use nerdy linguistics notation! For example, in Tamil, /k/ is pronounced as [g] after a nasal sound, so we can write /k/ → [g] / [ŋ]__. The underscore represents the position of this phoneme, and the slash indicates that the environment of this variation is about to come next.

A more tangible example, if you’re in the 98.94% of people who don’t speak Tamil, of allophonic variation is aspiration in English. You might notice that the “tone” in “stone” and “tone” are pronounced differently. Sure enough, in the IPA (broad transcription since we only care about aspiration), the first consonant or consonant cluster is pronounced as [t] and [tʰ] respectively. This is because aspiration is allophonic. At the beginning of a word, before a vowel, stops are aspirated, but they aren’t aspirated after a fricative. So, you could write /t/ → [tʰ] / #_V. The hashtag indicates the start of a word, and V represents a vowel.

Intuition for Phonemes

Does this whole idea of languages perceiving sounds feel kind of weird? It might be, because it is mainly subconscious, and also feels more like psychology than linguistics. However, let me show you why talking about phonemes is actually necessary.

The concept of phonemes can be boiled down to distinguishing between sounds. From the phonetics blog, you might remember that that are a BUNCH of different features that can be present in sounds. There’s not just place and manner of articulation, but also voice, gemination, nasality, and more.

Imagine that there was no such notion of distinguishing between those different features. Then, you would have a BUNCH of different sounds that all sound basically the same to you, based on every single combination of these features. Even if the features are just binary, which is the smallest amount of distinction in a feature, they would still grow exponentially, so 20 binary features would already give you over a million different sounds that you have to distinguish between. Theoretically, you could even have tiny, continuous distinctions, like the amount of time pronouncing a vowel. Then, you would have to deal with an infinite amount of different sounds. Therefore, all languages have a system of distinguishing sounds into phonemes.

Minimal Pairs

So, how do you know if a language distinguishes between two sounds? The main, most reliable way is to find minimal pairs. A minimal pair is two words that mean different things whose pronounciations differ by only one sound at the same, corresponding positions. For example, in English, “bag” and “back” ([bæg] and [bæk]) are a minimal pair, since they have different meanings and the only difference in their pronounciation is the [g] and [k], which means they are two different phonemes, /k/ and /g/. Typically, even one minimal pair suffices to show that two sounds are perceived as different phonemes, but more examples could help to provide further evidence.

Weird Example of Telugu with Sanskrit loanwords

Telugu is the most widely spoken Dravidian language. It has a lot of Sanskrit loanwords. In Sanskrit, [k], [g], [kʰ], and [gʰ] are all their own phonemes, but in native Dravidian vocabulary, they are allophones of the same phoneme /k/.

As a result, there are two layers of phonology in Telugu. The vocabulary that is from before the Sanskrit loanwords contains no minimal pairs that distinguish across aspiration or voicing, while the Sanskrit loanwords do contain such minimal pairs.

Fun fact: This is one reason why the Telugu script’s letters for voicing and aspiration are so much easier than Devanagari’s. Initially, the Telugu script only had one letter for all these sounds ( క ), like the Tamil ( க ). After borrowing the Sanskrit loanwords, they just added diacritics to that letter to represent those distinctions.

As a bonus fun fact, the reason why representing those Sanskrit loanwords was so important is because a lot of them were words that represented concepts that weren’t present in Telugu before, like a lot of Hindu ideas, and written text typically was about religious topics, so it was important not to cause any misunderstandings.

French Example of Phonology

Each language has its phonology written, by placing the accurate symbols of all of its phonemes. For example, see the phonology of French.

Representation of features as vectors

While you can describe the pronounciation of a phoneme using the IPA, a more helpful way is to describe that symbol with a vector of features, but only the features that are distinguished in a certain language. For example, in English, the phoneme /p/ might be represented as [+bilabial, +stop, -voice], while /b/ might be [+bilabial, +stop, +voice].

Example in Korean for how tones might develop

Lots of times, losing distinguishing features causes ambiguity, and new features naturally arise to resolve that ambiguity. One can observe this happening in Korean. Korean has a three-way distinction between /k/, /kʰ/, and /k͈/ (plain, aspirated, and tense). However, the younger generations of Korean speakers nowadays have a hard time distinguishing between the plain and tense phonemes, so their pronounciations start merging, and this results in a lot of homophones, which may create confusion. Younger speakers have been observed to use differences in pitch to fill in this gap in information. Over time, this could lead to the development of tones in future dialects of Korean. This is very similar to how tones developed in most Chinese languages, since Old Chinese actually was not tonal and had consonant clusters instead that simplified and converged over time and created ambiguity. This phenomenon is called tonogenesis, and is also currently happening in Afrikaans, which is spoken about 12,500 kilometers away.

Weird Edge Cases

Many phonological rules have strange edge cases that most people wouldn’t immediately think about. Here are some of them.

Structure of Syllables and Phonotactics

Each language has its own rule system for how certain phonemes can be placed together into words and syllables. Most syllables cross-linguistically have some sort of nucleus (typically a vowel, but sometimes some sonorant consonants), an optional onset (consonants before the nucleus), and an optional coda (any consonants after the nucleus). The combination of the nucleus and the coda is called the rhyme, which is why in poems, you would call rhyming words anything where the phonemes after the onset match.

Languages can vary in how restrictive or permissive they are with their syllable structure, and this is called phonotactics. Phonotactics also determine how syllables may stack together in words. Hawaiian, for example, is very restrictive, since the most complicated syllable structure it allows is CV (consonant + vowel), while English is very permissive, since it allows syllables like CCCVCCCC, in the word “strengths” (/strɛŋkθs/).

This is why some languages like Wifi Password Language (Polish) have a bunch of consonant clusters that English speakers find despicable; its most complex syllable is way, way, way longer than “strengths”. Meanwhile, Spanish’s phonotactics are pretty restrictive compared to English, which is why “student” is “estudiante” in Spanish; a consonant cluster may not begin a word, so they add a vowel at the beginning.

Conclusion

Now we know how languages’ perceived sounds interact with each other, but how does meaning form? Stay tuned for morphology.

Chill IPA Characters

Many letters are just like in English. For example, why don’t you take a random guess at how [p], [h], [v], [z], [m], [ɪ] and [t] are pronounced? Yes! They are pronounced like “p”, “h”, “v”, “z”, “m”, “ɪ” and “t”! BUT NOT LIKE “pea”, “aich”, “vee”, “zee”, “em”, “eye”, and “tea” - you need to hop off elementary school English if you said that.

Troll IPA Characters

However, there are some tricky ones too that are designed to deceive you. For example, what sounds do you think [j], [x], [ɑ], [r], [q], [c], and [ʔ] make? No, it is not “jay”, “eks”, “aey”, “ar”, “kyoo”, “see”, and “hmmm?”. Instead, they make the voiced palatal approximant, voiceless velar fricative, unrounded open back vowel, voiced alveolar trill, voiceless uvular stop, voiceless palatal stop, and the glottal stop (glottal stop doesn’t have a voiced version, because it’s just the break between “uh” and “oh” in “uh-oh”).

Greek IPA Letters

We’re not done. There’s even Greek letters, which somehow we can never evade, regardless of the subject. [ɸ], [θ], [ʎ], [ɤ], and [ʊ] are not phi, theta, lambda, gamma, and upside-down omega, but instead voiceless bilabial fricative, voiceless alveolar fricative, voiced palatal lateral approximant, back close-mid unrounded vowel, and then this random vowel that doesn’t know where it belongs. Phew. That torture is over. Or is it?

Diacritics Intro

We still have the diacritics to go over, but this time I won’t subject you to the pain of looking at every diacritic. Instead, I’ll just say that the diacritics can alter a sound to fit any of the variations for consonants and vowels I talked about earlier, such as nasality (so a nasalized [a] is [ã]), gemination (so a geminated [t] is [t:]), voicelessness (circle underneath), tone, and more.

Visualization

To see the visual representation of the IPA, and to actually listen to their sounds, click here.

To Be Continued

Now, since having a bunch of fancy symbols is meaningless on its own, we need to learn how sounds actually work so that they have a purpose.

Writing Systems

Pronunciation and Alphabet

Limit is written in Roman characters (for now, that is; we will introduce the real writing system later), but there are some rules to how the script works.

Consonants are mostly lowercase, with the only exception being the letter “L”, which is always capitalized. Each consonant is a short sound. Short vowel sounds are lowercase, while long vowel sounds are uppercase. The language is almost phonetic; the pronunciation is exactly what is written, apart from a few rules. There are no silent letters.

Examples for how to write and pronounce vowels:
1. A short “O” like in the word “dog” would be lowercase.
2. A long “A” like in the word “cake” would be uppercase.

Orthography

Every consonant (the default form of each phoneme, ignoring the allophonic variations) is a node representing its position in the IPA when you plot places against manners of articulation. The starting node is a hollow circle for voiceless consonants and a filled in circle for voiced consonants. You draw vectors from one node to the next to represent subsequent consonants. If a word starts with a vowel, you can start with either k or f, in accordance to the sandhi and allophony. If two consecutive consonants are the same, then the vector is a circle with radius , starting from that consonant and making a full loop through the -th roots of unity (where this node is the local origin), where is the number of consonants you have done before doing this repeated one, and drawing an arrow at the end before getting to that node again. For vowels in between consonants, draw a grid starting from the top-left corner of a vowel diagram to show how deep the vowel is. If the vowel is rounded, shade alternating squares (starting from the top-left corner) like a checkerboard, and otherwise, none of the squares are filled in. Specifically for /i/ and /y/ (since their rectangle would just be a point), draw an X or a ✔ on that line respectively.

Pronouns and Verbs

If you have a pronoun and a verb, you have a simple sentence, so let us start here in our journey to learn real Limit words. There is no gender or verb conjugation for each pronoun in Limit, so this should be simple.

Syntax

Here are some rules for sentence structure:

• The order of a declarative sentence is Subject Object Verb.
  
• Adjectives always come after nouns, attached by a slash, without spaces.
  
• Articles come after nouns as well, also attached by a slash without spaces.
  
• If there is an article and an adjective, the adjective comes after the article, and the adjective and the article are combined with slashes as well.
  
• Adverbs come before the verb or adjective that they modify, with a backslash with no spaces. If they modify an adjective, then it goes before the noun.
  
• There is no distinction between proper and common nouns.
  
• Prepositions work the same way as in English.
  
• Objects, like in English, do not have to just be nouns but also any verb phrase that acts as a noun. Predicate adjectives and predicate nominatives also count as objects.
  
• Prepositional phrases (like “in the house”) count as objects as well.
  
• Indirect objects come right before direct objects.
  
• Indirect objects have the suffix “b”, or “Ob” if the word ends in a consonant.
  
• Predicate adjectives would actually be adverbs, as they modify the word “bLIvUp”.
  Examples:
  Write “I like to eat” in Limit syntax and spelling.
  I tU Et LIk
  Write “I give you a green box” in Limit syntax and spelling.
  I yUhU boks/A/grEn giv

Inflections

To inflect a word ending in O, make the final consonant of the inflection thing voiceless. For example, the plural of “riLmO” (monkey) will be “riLmOt” instead of “riLmOd” (riLmOd is not a real word for that reason). And, the possessive of “riLmO” will be “riLmOf” instead of “riLmOv”. Likewise, you’d say “riLmOkE” instead of “riLmOgE”, “riLmOpU” instead of “riLmObU”, and “riLmOsA” instead of “riLmOzA”.

Punctuation

Commas are written as “~”.
Periods are written as “-”.
Quotation marks are written as “+” on either end of the quote.
Question marks are just a word, that being “LE”.

Possession

Adjectives

Adverbs

To turn an adjective into an adverb, add the prefix “.@”.
This is analogous to adding an “ly” at the end in English.
Adverbs go right before the adjective, verb, or adverb that they modify.
Example:
The word for “real” is “gOhO”, which means the word for “really” is “.@gOhO”.
I am really good = “LI .@gOhO\LimitO#U blivUL”

Allophony

Apply these variations in order:

• Any nasal followed directly by a vowel must be turned into a voiceless trill of the same place of articulation
  • For example, the “m” in “Limit” is pronouned like the “pppp” in Proto-Zorbbbb.
• Any word starting with a vowel is pronounced with an “f” if the vowel is rounded and a “k” if the vowel is unrounded.
• Any word ending with a vowel must be pronounced with the same consonants that are added if a word starts with a vowel, except rounded and unrounded are reversed.
• Any word ending with a consonant (which is all of them, at this point) must be pronounced, after the consonant, with a monkey scream (a shriek of [ɐ] at the top of your lungs) if the consonant is voiced and a grunt (a very low-pitch, almost confused-sounding [œ]) if the consonant is voiceless. This additional noise is never written. Also, the final consonant is an ejective consonant.
• Starting stops become fricatives, and starting fricatives become stops. This part only applies to pronunciation, not orthography.

Numbers

Base 10 is used, like normal.
One shorthand is implemented; whenever there is a 1 followed by a 0, it is written as θ.
Numbers are written as normal Arabic numerals, but obviously they are said differently.
0: “fA”
1: “hα”
2: “rO”
3: “d#U”
4: “yA”
5: “.a”
6: “brU”
7: “,O”
8: “we”
9: “gI”
To get more numbers, you do the following:
Write each digit in the bigger number as the sum of each digit times a power of . For example, would be .
You may know that “time ten to the power of” can also be written as “E”. In Limit, the symbol for this is ““=”, pronounced “sigmα”. Fun fact: this word also means “and”.
You would write the each place value from highest exponent to lowest.
Instead of saying plus, you would just combine each term with a slash.
Units digits do not need to be written as a=0, just a.
Back to the example of 243, in Limit you would say this as:
2=2/4=1/3, and pronounce this as rO=rO/yA=hα/jU, and remember that = is pronounced as sigmα.
For negative numbers, add the suffix “yO”.
For ordinal numbers, add the suffix “hO”, after the “yO” if it is there.
For fractions, just use the postposition for “in”, which is the suffix “krA” or “OkrA”. There will be a space after that.
You can also just list each digit, but then you must indicate the decimal point when applicable, which is pronounced as “%nd” and is written as “*”.
Example:
You would say “31.4th” as “jUhαyOhO”.

Questions

Just say the equivalent declarative sentence, then add “LE-” (which means question mark) to the end.
Phrasing Examples:
“Which one do you like?” -> “You one/which like LE-”
“How are you?” -> “You how are LE-”
Here’re the interrogative words:
What:

Commands

State the equivalent in a future tense declarative sentence, and speak in 2nd person. Use the word for please, “hok”, at the end of the sentence, after the verb.
Phrasing Examples:
“Go to bed.” -> “You will to bed go hok-”
Also, instead of saying “hok”, you can say “bOLOdOwO#O”, which is short for “bU LI dI wopLUkO#U”, which means something along the lines of “or I will kill you”.
Fun fact: the word “hok” is actually a loanword from Proto-Zorbbbb.

Prepositions

First, be sure to note that Limit uses a suffix for prepositions (so they are actually postpositions) like “in”, “at”, “during”, “of”, etc; this means anything that gives the position or time, not something that is being headed towards. This suffix is “gE”, or “OgE”, depending on if the word ends in a vowel or consonant.
There is also a suffix for something you are heading to. This includes words such as “before”, “to”, or “for”. The suffix is “bU”, or “ObU”, depending on if the word ends in a vowel or consonant.
Finally, for something you are coming from, such as “from”, “after”, or “past”, the suffix will be either “zA” or “OzA”.

General Rule of Affixes

If the word ends in a consonant, and the suffix starts with a consonant, then put an “O” between them.
If the word ends in a vowel and the suffix starts with a consonant, or the other way around, then there is no need for an extra “O”.
This same intuition is to be applied to prefixes.

Conjunctions

The conjunctions (subordinating and coordinating, and also including relative pronouns) are:
And: “=”
Or: “bI”
But: “pA”
So: “skibidE”
If: “*m”
Note for the next two: If these account for plural antecedents, then add a “d”.
Who/That/Which (as a subordinate): “Ligmα”
Whose: “Ligmαv”

Abbreviations

Just like how there’s “ts pmo” for [censored], in Limit there are abbreviations too. Except, between consonants, you must add a “@”. For example, bU LI dI wopLUkO#U becomes bOLOdOwO#O. Also, negation affixes are important enough to count as their own word, so just put #O at the end if it is negated, like in this one.

Comparatives and Superlatives

How you would phrase this:
[Subject] [Person, indirect form] [Attribute, locative form] [Win/Lose].
The [Person, indirect form] can be removed if the sentence is superlative.
Note that the indirect form and the locative form both have a postpositional ending, so it may be confusing.
The attribute must be a verb. Nouns, adjectives, and adverbs must be reworded.

VOCABULARY (in progress)

Alright, now that you know all the grammar rules, let’s get into the vocabulary, so you can actually speak in Limit. There aren’t that many vocabulary words, instead you must take the basic vocabulary words and combine them. To negate a word (to make it opposite, basically) add the suffix “O#U” or “#U”, which works for verbs, adjectives, nouns, etc. The core vocabulary is mainly for neutral or negative connotation, and to get positive connotation, just negate it.

Nouns:
Person: nUvak
Monkey: riLmO
Ignorance: zO*p
World: h%d
Non-primate organism: tEkU
Tool: dOmα*
Name: Eskα
Age: derUm
Evilness: Limit
Time: dUrin
Motion: cU
Size: pLevI
Color: snib
Goal: wOksO
X-axis: dAb
Y-axis: vEb
Z-axis: LUb
Nature: nuk
Quantity: LodO
Food: gla*nE
Set: rimU

Adjectives:

Evil: Limit
Small: pLevI
Slow: kU
Incorrect: kIf
Old: derUm
Ugly: t!Untab
Cold: mEkO
Late: dUrin
Yucky: gla*nE
Black: snib
Blue: mraflet
Yellow: krUgnip
Red: yundrask
Liquid: vUgis Weird: kitU

Verbs (infinitive):
Hate: netAbUp
Go: drekInUp
Use: gUatUp Make: wopLUp
Not know: zO*pUp Steal: prIksUp
Want: kutlOrUp