Learn about how Boolean logic works in C#.

Understanding Logic in C#

Computers are constantly checking the state of something. Is this program running or not? Does this variable exist or not? Is this value equal to that value? 

These yes or no questions demonstrate that a number of _binaries_ &mdash;a relationship between two entities&mdash;exist. Computer programs essentially function off of binaries: true and false, yes and no, ones and zeroes, on and off. 

Distinguishing between binaries is the foundation of _Boolean logic_. Boolean logic is based on the idea that all values are either _true_ or _false_. Logic is important to computer science because it is an early attempt at translating the human capacity for reason to computers. If a computer can use logic to reason about certain situations, it can use that rationale to make decisions. 

In this lesson, we'll explore how Boolean logic works in C# and show you how you can begin to implement boolean data types and expressions in your own programs. 


Introduction to Logic in C#

We can also use operators that use Boolean values as inputs and output. Logical operators, also known as Boolean operators, can be used to create Boolean expressions. 

Logical operators include:
- AND `&&`: Both expressions are evaluated and will return True _only_ if both expressions evaluate to True. Otherwise, it will return False. 
- OR `||`: Both expressions are evaluated and will return True if _at least one_ of the expressions evaluates to True. Otherwise, it will return False.
- NOT `!`: An expression, no matter its logical value, evaluates to its opposite. What is True becomes False and what is False becomes True.


Let's look at some examples: 
```csharp
bool andExample = ((4 > 1) && (2 < 7)); 
// (True AND True) evaluates to True
```
In this example, both comparisons evaluate to True, so the overall expression evaluates to True. 

```csharp
bool orExample = ((8 > 6) || (3 > 6));
// (True OR False) evaluates to True
```
Here, only one comparison evaluates to True and the other evaluates to False, so the expression evaluates to True.

```csharp
bool notExample = !(1 < 3);
// NOT (True) evaluates to False
```
In this last example, the comparison evaluates to True, so the expression evaluates to False.

A common way to visualize these relationships is using a diagram known as a _truth table_. Truth tables allow us to quickly see what the outcome is for different relationships between Boolean values. Handling two Boolean values is simple, but longer expressions can be very complex. It's crucial that you are familiar with these fundamentals before going ahead.

Truth table depicting relationships between Boolean values.

Truth Table

When writing a program, we often need to check if a value is correct or compare two values.
Comparison operators allow us to compare values and evaluate their relationship. Rather than evaluating to an integer, they evaluate to boolean values. Expressions that evaluate to boolean values are known as boolean expressions.

Comparison operators include:
- _Equals_ `==`: returns true if the value to the left is equal to the value to the right.
- _Inequality operator_ `!=`: returns true if the two values are not equal.
- _Less than_ `<`: returns true if the value to the left is less than the value to the right.
- _Greater than_ `>`: returns true if the value to the left is more than the value to the right.
- _Less than or equal to_ `<=`: returns true if the value to the left is less than or equal to the value on the right.
- _Greater than or equal to_ `>=`: returns true if the value to the left is more than or equal to the value to the right.

Here's what a boolean expression using comparison operators can look like:
```csharp
bool answer = 3 < 75; 
Console.WriteLine(answer); // prints True
```
In this example, we use the less than `<` comparison operator to compare the values `3` and `75`, then save the expression to a variable named `answer` with a `bool` data type. If we were to print the value of `answer` to the console, it would print out `True`, since the number 3 is less than the number 75. 

In addition to comparing integers, we can also compare variables, strings, and even boolean values: 

```csharp
bool answer = (true == false);
Console.WriteLine(answer); //prints False
```
Here, we use the equals comparison operator to see if the Boolean value `true` is equal to `false`. This time, the expression evaluates to false. We'll look more into comparing boolean values in the next exercise.


Comparison Operators

In C#, we can represent Boolean values using the `bool` data type. Booleans, unlike numbers or strings, only have two values: true and false.

To define a variable as a boolean, you define the data type as `bool`. Then write the variable name and set it equal to the value, either `true` or `false`:

```csharp
bool variableName = true;
```

The variable is named `variableName`, its of type `bool`, and its value is `true`. 

While we use the words `true` and `false` to represent boolean values, it’s important to remember that they are different from the strings `"true"` and `"false"`. 


Boolean Data Types

Great job! You just learned about logic and boolean values, including:
- How to define variables with a `bool` data type
- How to use comparison operators with different data types to return boolean values
- What a truth table is and how to read one
- How to use logical operators to compare boolean values and expressions

Now that you know a few things about boolean data types, comparison operators and logical operators, try writing a program that:
- Checks a password if it has uppercase letters and doesn't include symbols
- Tells you if you should watch a TV show if it has your favorite actor or is your favorite drama


Review

As we saw in the truth table, a Boolean expression that uses logical operators can be as simple as evaluating two boolean values:

```csharp
bool answer = true && false; // evaluates to False
```
In this case, we're saying that `answer` is equal to the evaluation of `true` AND `false`. According to the truth table, `answer` will return False. 

But more often, Boolean expressions are extremely complex. Rather than determining if one relationship is true or false, we can evaluate several expressions by connecting them with logical operators and then determining the validity of the overall expression.

```csharp
bool answer = (9 < 3) || (100 < 45); // evaluates to False
bool another = ((3439 > 40) && (1 < 3)) || answer; // evaluates to True
```
We can use logical values to start chaining logical statements. 
Let's start by finding the value of `answer`. 

First, the computer will evaluate each comparison statement:
- `bool answer = (9 < 3) || (100 < 45)`

Both of these statements evaluate to false:
- `bool answer = false || false`

Since both statements evaluate to false and we're using an OR operator, the overall expression will return false:
- `bool answer =  false`

Now we can start evaluating the value of `another`. 
Again, we'll start by evaluating the comparison statements:
- `bool another = ((3439 > 40) && (1 < 3)) || answer`

Both statements evaluate to true:
- `bool another = (true && true) || answer`

Since both statements evaluate to true and we're using an AND operator, the overall expression returns true: 
- `bool another = true || answer`

Since we already know that `answer` is false and we're evaluating it with a true value using an OR operator `another`, it will return true:
- `bool another = true`.
