**Basic Logic: How to Make Classical Logic Machine-Readable**

Remember that Logical AI is all about making computers capable of reading and interpreting human sentences. If you think about this for a bit, you will probably realize that this is one of humanity’s greatest feats, only second to the invention of the alphabet and written language itself. The invention of the alphabet at around 1700 B.C. in the Middle East allowed humans to store knowledge in written documents and to communicate at a distance both in space and time.

With the emergence of Logical AI in the second half of the last century, humans became capable of communicating with machines via written languages that no one really speaks, called programming languages. You can do amazing things with these languages, but only a logical programming language gives you the power of truth, as we discussed in the previous article of this series. This is one of the reasons why Tau invests so much in logic — despite the great complexity of this subject.

In particular, at Tau we are classics, i.e. we work with classical logic, or the logic that has only two truth values, true (1) and false (0). This gives us the certainty that if a sentence is not true, then it can only be false, and vice-versa, so that ambivalence and ambiguity are ruled out. (This may not sound so good at first, appearing rather rigid in comparison to all the things that you can say or think, but on second thought you will realize that it has many advantages.) In other words, we use classical logic. For now, let us stick to propositional logic as a matter of simplicity.

The atomic expressions — sentences — of this logic are called *propositions *and are abstracted by means of the lowercase letters *p*, *q*, *r*, … For instance, you can abstract the proposition “It rains a lot in Winter” as, say, *p*. The sentences of this logic come usually in five forms depending on their main logical connective or operator:

NOT-*p* (called negation)

*p* AND *q* (conjunction)

*p* OR *q* (disjunction)

IF *p*, THEN *q* (material conditional)

*p* IF AND ONLY IF *q* (biconditional)

As you can guess, with these five logical connectives you can express a lot of what you say in English (or any other natural language).

When we want to input logical sentences into a computer, we need what is called computational logic, a field with a lot of algorithms to change logical sentences into other equivalent ones. Computers are not as flexible as humans and they typically do not accept sentences with the connectives of material conditional and biconditional. No problem: we define them by means of the other connectives of classical logic — a property known as functional completeness — in the following way:

IF *p* then *q* := NOT-*p* OR *q*

*p* IF AND ONLY IF *q* := (IF *p* THEN *q*) AND (IF* q* THEN *p*)

If you reflect on it, saying “If it rains, then I will stay at home” is the same as saying “Either it does not rain or I will stay at home.” You can apply the same reasoning with a biconditional sentence.

So, computers typically accept only the Boolean connectives: NOT, AND, OR. These can be put together in specific combinations, of which CNF, the abbreviation for *conjunctive normal form*, is a very usual one. CNFs are sentences that are conjunctions of disjunctions. For instance, the following sentence is in CNF:

(*p* OR NOT-*q* OR *r*) AND (NOT-*p* OR NOT-*r*) AND (*q* OR *r*)

Unfortunately, nothing comes for free in computational logic, and converting a propositional sentence in classical logic into CNF can be quite tricky and, depending on the algorithm used to do it, the latter can be much bigger than the original sentence — in fact, it can be *too *big. But fortunately, there are algorithms that reduce this “explosion” in CNFs, so this does not really pose an insurmountable problem. This means that you can use CNFs galore, so keep this abbreviation in your logical lexicon; it occurs many times and in central aspects of Logical AI.