# Introduction to formalisation in propositional logic

Propositional logic is a formal language (we shall not enter into a definition of a "formal language.") It has three kinds of symbols which may vary in each presentation. We'll define them as:
* Sentence letters: a, b, c.... z.
* Operators (aka. connectives): ~, ^, v, ->, <->.
* Parentheses: (, ). Used for organization purposes, similar to parentheses in algebra and arithmetic.
In the common use of propositional logic, sentence letters stand for complete sentences. Our interest here is to learn to symbolize natural language into propositional logic, so we will take for granted that every letter we use represents a sentence.

## Reading statements in propositional logic

We will review the way that operators are usually read without entering into their semantic properties.
* $p$, read as "p".
* $\neg p$, read as "not p" or "it is not the case that p".
* $p\wedge q$, read as "p and q".
* $p\vee q$, read as "p or q"; that is, "p or q, or both".
* $p\rightarrow q$, read as "if p, then q" or "p implies q".
* $p\leftrightarrow q$, read as "p if and only if q"; sometimes written as "p iff q".

## Symbolization

Symbolization is a process that turns a meaning into something expressed in a symbol (something that stands for something) or in our context, in a symbolic language. For example, outside the domain of logic, if we have a fifty dollars we may symbolize this in our balance book as "$50". In turn, when we find the symbol "$50" we have to interpret it (the usual interpretation is "fifty dollars"). In natural languages (English, French, etc) the process of "interpretation" is often subjective and unclear, in formal languages (propositional logic, C++, etc) the interpretation is precise and clear. A puzzling thing is that interpretation is not necessary in formal languages. A computer may learn the rules of arithmetic (a formal language) and make operations correctly without knowing the meaning of the symbols. However, when we use a formal language for something we usually want to give it an interpretation. We're going to learn to symbolize a sentence in natural language using symbolic logic. In the process, something is going to be lost. If I have $100 and I buy a $10 hotdog I can symbolize this as= "$100 - $10 = $90" Nowhere in the subtraction does it say that I ate a hotdog. We're losing information but we're gaining in precision and we may apply operations that obtain conclusions that maybe (imagine an extremely long hotdog shopping spree expressed as a subtraction) weren't obvious at first sight. This will be the objective of symbolizing natural language in propositional logic.

## Symbolizing sentences

The standard procedure is to define letters with the sentences they stand for. Example:
* p = Pork is expensive.
* q = Honey is cheaper than pork.
* etc.
When symbolizing, one should try to break each natural language sentence into an atomical sentence. An atomical sentence is one that cannot be separated into further sentences. This way, we can make use of the best level of precision propositional logic can give us. For instance, the natural language sentence: "My sister and I like coffee" could be defined:
* m = My sister and I like coffee.
But also:
* n = My sister likes coffee.
* o = I like coffee.
For the time being, we don't mind the logical relation between sentences. We will use operators later to convey that. At this stage, both "my sister and i like coffee" and "if my sister likes coffee i like coffee" will be broken down into:
* n = My sister likes coffee.
* o = I like coffee.
As we will later see, we have an operation to express "negation". So a negative sentence will be better expressed as a positive sentence, and later we can add the correct symbol. That is, the atomic constituents of "I don't like the bomb." are:
* b = I like the bomb.
The sentence "I don't like the bomb but you will be a bad person if you don't understand me" can be broken into:
* a = I like the bomb.
* b = You will be a bad a person.
* c = You understand me.
This article is in progress