# 45 Booleans

The two boolean values are `true` and `false`. They stand for the logical values of the same name. They appear mainly as values of the conditions in `if`-statements and `while`-loops.

This chapter contains sections describing the operations that are available for the boolean values (see Comparisons of Booleans, Operations for Booleans).

Further this chapter contains a section about the function `IsBool` (see IsBool). Note that it is a convention that the name of a function that tests a property, and returns `true` and `false` according to the outcome, starts with `Is`, as in `IsBool`.

## 45.1 Comparisons of Booleans

`bool1 = bool2`, `bool1 <> bool2`

The equality operator `=` evaluates to `true` if the two boolean values bool1 and bool2 are equal, i.e., both are `true` or both are `false`, and `false` otherwise. The inequality operator `<>` evaluates to `true` if the two boolean values bool1 and bool2 are different and `false` otherwise. This operation is also called the exclusive or, because its value is `true` if exactly one of bool1 or bool2 is `true`.

You can compare boolean values with objects of other types. Of course they are never equal.

```    gap> true = false;
false
gap> false = (true = false);
true
gap> true <> 17;
true ```

`bool1 < bool2`, `bool1 <= bool2`,
`bool1 > bool2`, `bool1 >= bool2`

The operators `<`, `<=`, `>`, and `=>` evaluate to `true` if the boolean value bool1 is less than, less than or equal to, greater than, and greater than or equal to the boolean value bool2. The ordering of boolean values is defined by `true < false`.

You can compare boolean values with objects of other types. Integers, rationals, cyclotomics, permutations, and words are smaller than boolean values. Objects of the other types, i.e., functions, lists, and records are larger.

```    gap> true < false;
true
gap> false >= true;
true
gap> 17 < true;
true
gap> true < [17];
true ```

## 45.2 Operations for Booleans

`bool1 or bool2`

The logical operator `or` evaluates to `true` if at least one of the two boolean operands bool1 and bool2 is `true` and to `false` otherwise.

`or` first evaluates bool1. If the value is neither `true` nor `false` an error is signalled. If the value is `true`, then `or` returns `true` without evaluating bool2. If the value is `false`, then `or` evaluates bool2. Again, if the value is neither `true` nor `false` an error is signalled. Otherwise `or` returns the value of bool2. This short-circuited evaluation is important if the value of bool1 is `true` and evaluation of bool2 would take much time or cause an error.

`or` is associative, i.e., it is allowed to write `b1 or b2 or b3`, which is interpreted as `(b1 or b2) or b3`. `or` has the lowest precedence of the logical operators. All logical operators have lower precedence than the comparison operators `=`, `<`, `in`, etc.

```    gap> true or false;
true
gap> false or false;
false
gap> i := -1;;  l := [1,2,3];;
gap> if i <= 0 or l[i] = false  then Print("aha\n");  fi;
aha    # no error, because `l[i]` is not evaluated ```

`bool1 and bool2`

The logical operator `and` evaluates to `true` if both boolean operands bool1 and bool2 are `true` and to `false` otherwise.

`and` first evaluates bool1. If the value is neither `true` nor `false` an error is signalled. If the value is `false`, then `and` returns `false` without evaluating bool2. If the value is `true`, then `and` evaluates bool2. Again, if the value is neither `true` nor `false` an error is signalled. Otherwise `and` returns the value of bool2. This short-circuited evaluation is important if the value of bool1 is `false` and evaluation of bool2 would take much time or cause an error.

`and` is associative, i.e., it is allowed to write ```b1 and b2 and b3```, which is interpreted as `(b1 and b2) and b3`. `and` has higher precedence than the logical `or` operator, but lower than the unary logical `not` operator. All logical operators have lower precedence than the comparison operators `=`, `<`, `in`, etc.

```    gap> true and false;
false
gap> true and true;
true
gap> false and 17;
false    # is no error, because `17` is never looked at ```

`not bool`

The logical operator `not` returns `true` if the boolean value bool is `false` and `true` otherwise. An error is signalled if bool does not evaluate to `true` or `false`.

`not` has higher precedence than the other logical operators, `or` and `and`. All logical operators have lower precedence than the comparison operators `=`, `<`, `in`, etc.

```    gap> not true;
false
gap> not false;
true ```

## 45.3 IsBool

`IsBool( obj )`

`IsBool` returns `true` if obj, which may be an object of an arbitrary type, is a boolean value and `false` otherwise. `IsBool` will signal an error if obj is an unbound variable.

```    gap> IsBool( true );
true
gap> IsBool( false );
true
gap> IsBool( 17 );
false ```

gap3-jm
02 Dec 2021