Discrete math with computers_3

•The base case is a simple statement of some mathematical fact, such as 1 S;

•The induction case is an implication in a general form, such as the proposition that

x U, x S → x + 1 S.

•The extremal clause says that nothing is in the set being defined unless it got there by a finite number of uses of the first two cases.

9.2.1Inductive Definition of the Set of Natural Numbers

We will illustrate the method by writing an inductive definition of the natural numbers.

Definition 26. The set N of natural numbers is defined as follows:

•Base case: 0 N

•Induction case: x N → x + 1 N

•Extremal clause: nothing is an element of the set N unless it can be constructed with a finite number of uses of the base and induction cases.

Now we can use the base and induction cases to show formally that an arbitrary number above and including 0 is a natural number. Let’s choose the number 2.

Exercise 9. Here is a Haskell equation that defines the set s inductively. Is 82 an element of s?

s :: [Integer]

s = 0 : map ((+) 2) s

Exercise 10. What set is defined by the following?

s :: [Integer]

s = 1 : map ((*) 3) s

9.2.2The Set of Binary Machine Words

Now we define a set BinWords, each of which is a machine word represented in binary notation. In general, a machine word can be of any length.

The base case says that the elements of another set (the set of binary digits) are also elements of BinWords. The induction case uses concatenation to create a new value from one already in the set. We represent the concatenation of a character to a string by placing them one after the other: e.g., ‘1’ ‘01’ is the string ‘101’.

Definition 27. Let BinDigit be the set {0, 1}. The set BinWords of machine words in binary is defined as follows:

• Base case:

x BinDigit → x BinWords

•Induction case: if x is a binary digit and y is a binary word, then their concatenation xy is also a binary word:

(x BinDigit y BinWords) → xy BinWords

•Extremal clause: nothing is an element of BinWords unless it can be constructed with a finite number of uses of the base and induction cases.

A set based on another set S in this way is given the name S+, indicating that it is the set of all possible non-empty strings over S. The expression S is the same as S+ except that S also includes the empty string. Thus our set

BinWords could be written BinDigit+.

We can write a Haskell function to calculate the set of binary words, using the inductive definition just presented. The induction function takes a binary word. It creates a new one from that number and each binary digit in turn. For example, if it is given [1,0], it returns [0,1,0] and [1,1,0].

The induction rule takes a binary word and creates two new ones, so we define the function newBinaryWords to do just that:

newBinaryWords :: [Integer] -> [[Integer]] newBinaryWords ys = [0 : ys, 1 : ys]

Finally, we define the set of binary words as follows:

mappend :: (a -> [b]) -> [a] -> [b] mappend f [] = []

mappend f (x:xs) = f x ++ mappend f xs

binWords = [0] : [1] :

(mappend newBinaryWords binWords)

Exercise 11. Alter the definition of newBinaryWords and binWords so that they produce all of the octal numbers. An octal number is one that contains only the digits 0 through 7.

9.3Defining the Set of Integers

Now we come to a more subtle problem: defining the set I of integers. Instead of just giving the final answer, we will think through the problem the way you might in real life. Each time we have a trial solution, we will examine it to see if it works and whether it can be improved.

The sets we have been defining are well-founded; that is, they are infinite only in one direction, and they have a least element. The set N of natural numbers is a good example of a well-founded set.

A countable set is one that can be counted using the natural numbers (see Chapter 11). Are the integers countable? They don’t have a least element, and they are infinite in two directions, so they aren’t well-founded. But we could use a trick: start from 0 and count first n then −n. If we think of the integers as a measuring tape that is infinitely long in two directions, we could still count the inches (or centimetres) on the tape by thinking of the tape as being folded at 0. Now the positive numbers touch the negative numbers, and each element i of the naturals counts both the positive and the negative numbers; that is, i counts (i, −i).

We have just devised a way of enumerating the integers so that every element is eventually counted. This forms an excellent basis for an inductive definition of the integers. We will now work through several attempts to define the integers using induction. Some of these have problems, and we discuss how to debug them.

9.3.1First Attempt

Attempt 1. The set I is defined as follows:

•Base case: 0 I

•Induction case: x I → −x I

•Extremal clause: nothing is in I unless its presence is justified by a finite number of uses of the base and induction cases.

We will now define some functions that will make our inductive definitions easier to understand and also make it possible to use the computer to help carry out experiments with the definition. Each of these is designed to take the base and induction cases as arguments and construct the data recursion automatically. The first uses map and the second uses mappend.

build :: a -> (a -> a) -> Set a build a f = set

where set = a : map f set

builds :: a -> (a -> [a]) -> Set a builds a f = set

We can be sure that this definition is correct because the induction step brings both the positive and negative numbers into I. Each element of I is incremented, guaranteeing that the naturals will be included as 1 and its successors are added. Each element of I is also decremented, ensuring that all of the negative numbers will be included as -1 and its predecessors are added.

A drawback, however, is that there are two ways for 0 to become a member of I. The base case puts it there, and step 5 does it again. In fact, the real defects of this definition are graphically illustrated by the fact that

take 20 integers2

= [0,1,-1,2,0,0,-2,3,1,1,-1,1,-1,-1,-3,4,2,2,0,2]

It is more elegant if the definition introduces each element only once. Furthermore, practical software based in an inductively defined set would be inefficient (and possibly even incorrect) if the elements were introduced more than once. Here is one way to try to fix the problem:

Attempt 3. The set I is defined as follows:

•Base case: 0 I

•Induction case: x I → (x + 1 I −(x + 1) I)

•Extremal clause: nothing is in I unless its presence is justified by a finite number of uses of the base and induction cases.

Here is an implementation of the third definition:

nextIntegers3 :: Integer -> [Integer] nextIntegers3 x = [x + 1, -(x + 1)]

integers3 :: [Integer]

integers3 = builds 0 nextIntegers3

Exercise 14. Use the computer to examine the first 10 integers generated by this definition, and describe the set that is defined.

9.3.4Fourth Attempt

This third attempt is a correct definition of the set of integers, and it is much closer to our intuition. What we want to do is say that if x is in I, then −x is also in I. However, we also have to increment and decrement x somehow, so that all the integers can be included. Consider what happens when we attempt to show that -2 is in I:

This is almost what we want, except that when the induction rule is instantiated with -1 it places 0 in I again. And,

take 10 integers3 = [0,1,-1,2,-2,0,0,3,-3,-1].

Therefore Attempt 3 doesn’t introduce each element precisely once.

Attempt 4. The set I of integers is defined as follows:

•Base case: 0 I

•Induction case:

1.(x I x ≥ 0) → x + 1 I

2.(x I x < 0) → x − 1 I

•Extremal clause: nothing is in I unless its presence is justified by a finite number of uses of the base and induction cases.

Here is an implementation of the fourth definition:

nextInteger4 :: Integer -> Integer nextInteger4 x = if x < 0 then x - 1 else x + 1

integers4 :: [Integer] integers4 = build 0 nextInteger4

Exercise 15. Use the computer to generate some elements of the set defined by Attempt 4, and describe the result.

9.3.5Fifth Attempt

Attempt 4 does not work, because the numbers generated from 0 must always be positive. It is necessary to go back to Attempt 4 and improve that. Furthermore, it would be better to have only one inductive case, if possible.

Attempt 5. The set I of integers is defined as follows:

•Base case: 0 I

•Induction case: (x I x ≥ 0) → x + 1 I −(x + 1) I

•Extremal clause: nothing is in I unless its presence is justified by a finite number of uses of the base and induction cases.

This definition is exactly what the original method of counting the integers suggested. It is implemented by the following Haskell program:

nextIntegers5 :: Integer -> [Integer] nextIntegers5 x

= if x > 0 \/ x == 0

then [x + 1, -(x + 1)] else []

integers5 :: [Integer]

integers5 = builds 0 nextIntegers5

Exercise 16. Use the computer to evaluate the first 10 elements of the set, and describe the result.

9.4Suggestions for Further Reading

Many of the references on set theory cited in Chapter 8 also deal with inductive definitions of sets. Elements of Set Theory, by Enderton [11], gives some good examples of inductively defined sets. A more advanced treatment appears in

Axiomatic Set Theory, by Suppes [30].

9.5Review Exercises

Exercise 17. Does ints, using the following definition, enumerate the integers? If it does, then you should be able to pick any integer and see it eventually in the output produced by ints. Will you ever see the value -1?

nats :: [Integer] nats = build 0 (1 +)

Exercise 18. Does twos enumerate the set of even natural numbers?

twos :: [Integer] twos = build 0 (2 *)

Exercise 19. What is wrong with the following definition of the stream of natural numbers?

nats = map (+ 1) nats ++ [0]

Exercise 20. What is the problem with the following definition of the naturals?

naturals :: [Integer] -> [Integer] naturals (i:acc) = naturals (i + 1:i:acc)

nats :: [Integer] nats = naturals [0]

Exercise 21. Can we write a function that will take a stream of the naturals (appearing in any order) and give the index of a particular number?

Exercise 22. Using induction, define the set of roots of a given number n.

Exercise 23. Given the following definition, prove that n3 is in set P of powers of n.

Definition 28. Given a number n, the set P of powers of n is defined as follows:

•n0 P

•nm P → nm+1 P

•Nothing else is in P unless it can be shown to be in P by a finite number of uses of the base and induction rules.

Exercise 24. When is 0 in the set defined below?

Definition 29. Given a number n, the set N is defined as follows:

•n N

•m N → m − 2 N

•Nothing is in N unless it can be shown to be in N by a finite number of uses of the previous rules.

Exercise 25. What set is defined by the following definition?

Definition 30. The set S is defined as follows:

• 1 S

• n S n mod 2 = 0 → n + 1 S

• n S n mod 2 = 1 → n + 2 S

•Nothing else is in S unless it can be shown to be in S by a finite number of uses of the previous rules.

Exercise 26. Prove that 4 is in the set defined as follows:

Definition 31. The set S is defined as follows: 1. 0 S

2. n S n mod 2 = 0 → n + 2 S

3. n S n mod 2 = 1 → n + 1 S

4.Nothing is in S unless it can be shown to be in S by a finite number of uses of the previous rules.

Exercise 27. Given the following definition, prove that the string ‘yyyy’ is in

YYS.

Definition 32. The set YYS of strings containing pairs of the letter ’y’ is defined as follows:

1."" Y Y S

2.s Y Y S → "yy" ++ s Y Y S

3.Nothing else is in YYS unless it can be shown to be in YYS by a finite number of uses of rules (1) and (2).

Exercise 28. Using data recursion, define the set of strings containing the letter ‘z’.

Exercise 29. Using induction, define the set of strings of spaces of length less than or equal to some positive integer n.

Exercise 30. Using recursion, define the set of strings of spaces of length less than or equal to length n, where n is a positive integer.

Exercise 31. We could have a set that consists of all the natural numbers except for 2; you can write this as N − {2}. Similarly, for every natural number x, there is a set that contains all the natural numbers except for x. Now, we could make a set SSN of all of these results. Write an inductive definition of SSN.

Exercise 32. Given the following definition, show that the set I − {−3}

SSI−.

The set of sets of integers SSI, each of which is missing a distinct negative integer, is defined inductively as follows:

1.I − {−1} SSI−

2.I − {n} → I − {n − 1} SSI−

3.Nothing else is in SSIunless it can be shown to be in SSIby a finite number of uses of rules (1) and (2).

Exercise 33. Given the following definition, prove that -7 is in ONI. The set ONI of odd negative integers is defined as follows:

1.−1 ON I

2.n ON I → n − 2 ON I

3.Nothing is in ONI unless it can be shown to be in ONI by a finite number of uses of the previous rules.

Exercise 34. Using data recursion, define the set ni of negative integers.

Exercise 35. If you print the elements of

[(a,b) | a <- [0..], b <- [0..]] will you ever see the element (1,2)?

Exercise 36. What set is given by the following definition?

Definition 33. The set S is defined as follows:

1.1 S

2.n S → n − n S

3.Nothing is in S unless it can be shown to be in S by a finite number of uses of the previous rules.