Hey @ladylinkstart

Okay, let's try breaking these down one by one.

I'll try to show how the comparisons are broken down into simple true and false statements, so that hopefully the final value will make sense.

**boolean_1 = (3 < 4 || false) && (false || true)**

First, we essentially have two groupings as defined by the parentheses, (3 < 4 || false) and (false || true). Since they are separated by &&, (called logical AND), it means that both sides needs to be true, in order for it to return true.

So, checking out (3 < 4 || false), this one is split by ||,(called logical OR), which means that either of the sides need to be true, for this one to return true.

Since 3 is less than 4 (3<4), this part will return true to the left side of the '&&' comparison.

**boolean_1 = (true) && (false || true)**

On the right side, we have (false || true), which will also return true since the right hand side of the || operator is true.

**boolean_1 = (true) && (true)**

Since we now only have two 'true' statements on each side of the && operator, this one will return true.

**boolean_1 = true**

Now, onto the next one

**boolean_2 = !true && (!true || 100 != 5**2)**

We'll do the same thing, and start with the inner parentheses.

On the left side of the || operator, we have !true, where the '!' sign in front of true means to get the opposite value, which will be false.

**boolean_2 = !true && (false || 100 != 5**2)**

On the right side of || operator we have a new operator here, !=, which checks that the values on both sides are NOT equal.

Since 5**2 (** meaning multiply left side number with itself as many times on the right side) is equal to 25, 100 will not be equal to 25 and return true.

**boolean_2 = !true && (false || true)**

Then to finish up the inner parentheses, we get

**boolean_2 = !true && (true)**

Since the left side of && operator is !true, it will be false

**boolean_2 = false && true**

And since && needs both sides to be true, this will fail

**boolean_2 = false**

And finally the third one

**boolean_3 = true || !(true || false)**

Run inner parentheses first

**boolean_3 = true || !(true)**

Now, since there's a ! in front of the parentheses, when removing them, we need to invert the value inside of it

**boolean_3 = true || false**

And since || only needs true to be on either side

**boolean_3 = true**

**NB**

Take notice to the second and third tests.

On the second one, we can see that we need to compare !true with everything else on the right side of &&. However, since !true will be false, the && comparison will already fail, making the rest of the right hand side of the && operator unnecessary in order to find the result.

This is also similar to the third test, where the left hand side of || is true, and with || only needing either side to be true, this one will already be valid without having to check the rest on the right hand side of ||.