Introduction To Artificial Intelligence With Code: Part 1

When ChatGPT became a global phenomenon, books, papers, or articles about AI (Artificial Intelligence) appeared in countless numbers, but most of them were heavy on theory and mathematics.

The series of articles "Introduction to Artificial Intelligence with Code" is a compilation of the most fundamental aspects of AI for beginners, presented with a combination of theory and code (C#) to help readers gain a better understanding of the concepts and ideas discussed in these articles. In the first article of the series, we will introduce propositional logic.

Theory: An Introduction to Propositional Logic

The rules of logic provide precise meanings for propositions. These rules are used to distinguish between valid and invalid mathematical arguments. Alongside its significance in understanding mathematical reasoning, logic also has many applications in computer science, such as designing computer networks, programming, checking program correctness, and so on.

Propositions are the building blocks of the logical edifice of propositional logic. A proposition is a statement that is either true or false but cannot be both true and false simultaneously. The truth value of a proposition (in propositional logic) is referred to as its logical value (true or false).

Letters are used to symbolize propositions, as well as to represent variables in programming. The commonly used conventions for these letters are p, q, r, s, and so on.

Many mathematical propositions are created by combining one or more propositions we already have. These new propositions are called compound propositions (denoted temporarily as F), and they are formed from existing propositions using logical operators. Some basic logical operators are AND, OR, and NOT. A classical application of logical operators in computer science is to design logic gates. 

To check the truth value of a compound proposition, we need to apply the rules of logic and consider the truth values of the individual propositions along with the logical operators used.

Coding: Checking the Truth Value of a Compound Proposition (F)

We’ll create a set of classes, all related by inheritance, that will allow us to obtain the output of any F from inputs defined a priori. Here is the first class:

public abstract class F
{
  public abstract bool Check();
  public abstract IEnumerable<Prop> Props();
}

The abstract F class states that all its descendants must implement a Boolean method Check() and an IEnumerable<Prop> method Props(). The first will return the evaluation of the compound proposition and the latter the propositions contained within it. Because logical operators share some features, we’ll create an abstract class to group these features and create a more concise, logical inheritance design. The Op class, which can be seen in the code below, will contain the similarities that every logical operator shares:

public abstract class Op : F
{
  public F P { get; set; }
  public F Q { get; set; }
  public Op(F p, F q)
  {
     P = p;
     Q = q;
  }
  public override IEnumerable<Prop> Props()
  {
    return P.Props().Concat(Q.Props());
  }
}

The first logical operator, the AND, is illustrated:

public class AND: Op
{
  public AND(F p, F q): base(p, q)
  { }
  public override bool Check()
  {
    return P.Check() &&Q.Check();
  }
}

The implementation of the AND class is pretty simple. It receives two arguments that it passes to its parent constructor, and the Check method merely returns the logic AND that is built into C#. Very similar are the OR, NOT, and Prop classes, which are shown below:

//OR class
public class OR : Op
{
  public OR(F p, F q): base(p, q)
  { }
  public override bool Check()
  {
    return P.Check() || Q.Check();
  }
}
//NOT class
public class NOT : F
{
  public F P { get; set; }
  public NOT(F p)
  {
   P = p;
  }
  public override bool Check()
  {
    return !P.Check();
  }
  public override IEnumerable<Prop> Props()
  {
   return new List<Prop>(P.Props());
  }
}

The Prop class is the one we use for representing propositions in compound propositions. It includes a truthValue field, which is the truth value given to the proposition (true, false), and when the Props() method is called it returns a List<Prop> whose single element is itself:

public class Prop : F
{
  public bool truthValue { get; set; }
  public Prop(bool truthvalue)
  {
    truthValue = truthvalue;
  }
  public override bool Check()
  {
    return truthValue;
  }
  public override IEnumerable<Prop> Props()
  {
   return new List<Prop>() { this };
  }
}

Creating and checking F =  NOT(p) OR q:

var p = new Prop(false);
var q = new Prop(false);
var f = new OR(new NOT(p), q);
Console.WriteLine(f.Check()); 
p.trueValue = true;
Console.WriteLine(f.Check()); 

The result looks like this:

Summary

In this article, we introduced a basic logic — propositional logic — and we also described C# code for representing compound propositions (propositions, logical operators, and so on). In the next article, we’ll introduce a very important logic that extends propositional logic: first-order logic.