January:05(Mon)

MTH 225 Exercise-Set #1

Due January 14 (Wednesday)

Read our textbook's Chapter 1.
While each of you needs to learn all the course material here, e.g. so you'll know it for tests, I actually want you to do homework in teams of two for this course. (In case it's not clear, this means working together and doing only one submission rather than having two submissions, one from each teammate.) An advantage for you to do this is that you should get scores higher than you would otherwise, because I expect that you'd be checking each other's work. An advantage for me if you do this is that it would cut in half my workload for grading — in some sense, your checking each other's work would be doing some of the work of grading. But then, considering how your working in teams would shift some of my workload to you that way, plus considering the hassle it may be for you to coordinate working with another person, I'll reward people who work in teams of two by increasing their score by five percent.
But if you still won't work in a team of two even considering the advantages/rewards I've indicated for that (say because you just can't do it for some reason), don't worry about other people receiving higher grades than you unfairly, just because they work in teams and you don't: I will determine grade cutoffs ("A-"/"B+", "B"/"B-", etc.) according to the base scores, not the scores with those extra rewards added. Thus, even if you work alone, you can still get scores that are considered perfect and thus get an "A" in this course.
Incidentally, this policy is for this particular class that I'm teaching. Other classes — even other classes that I teach — may have different policies. So, you shouldn't think that working in teams is OK in other classes unless the policies given to you in those other classes say that it's OK.
One last point about this is as follows: Don't do homework in teams of more than two here: If you do that, I would actually consider it excessive sharing/division of work for this course.

Where it's appropriate, show intermediate work/explanations for obtaining answers. (If you're not sure where it's appropriate, ask.)

Do the following exercises of Section 1.1 in our textbook:
- [3 points] 1.1.2
- [2 points] 1.1.8b,e
- [6 points] 1.1.10.
- [3 points] 1.1.12
  Don't forget to show intermediate work for this exercise (students have neglected this in the past).
- [3 points] 1.1.14
  Except for Part b, instead of the given statement, use the following statement:
  If 1 + 1 = 3, then ice is cold.
  
  Don't forget to show intermediate work for this Exercise 1.1.14 (students have neglected this in the past).
- [2 points] 1.1.16a,b
- [5 points] 1.1.18a,c,d,e,g
- [2 points] Do the same operation as with Exercise 1.1.18 for the statements listed in Exercise 1.1.24bc.
  For this assignment, you do not need to do the work that the textbook specifies for Exercise 1.1.24.
- [10 points] 1.1.28a,d,e
- [4 points] 1.1.32e
[2 points] At one point in a Java program (named ProofBuilder) which I wrote, I wanted to express the condition that if one variable named argument2 wasn't null, then a second variable named argument1 shouldn't be be null. That is to say, I wanted to express the following condition in my Java code:
```
    (argument2 ≠ null) → (argument1 ≠ null)
```
In case you're wondering, the specific type of Java statement that I was writing here was an assert statement; but if you want you can consider the situation as though I was writing an if statement as follows:
```
    .
    .
    .
    if (  _________  )  // "(argument2≠null) → (argument1≠null)"
        {
        .
        .
        .
```
Thus, I wanted to complete the underline blank "________" there with a Java expression which would have the value true when argument2≠null is true and argument1≠null is true, the value false when argument2≠null is true and argument1≠null is false, the value true when argument2≠null is false and argument1≠null is true, and the value true when argument2≠null is false and argument1≠null is false.
But Java doesn't have a simple operator clearly corresponding to the logical connective "→" ("implies"). So what needed to be done here wasn't so straightforward.
How can this problem be solved? Give a Java expression that one could write in the head of the if statement here, equivalent to the logical expression "(argument2≠null) → (argument1≠null)". (You need to write just one Java expression fitting in the if statement to solve this problem; I'm not interested in code that is radically restructured or something.)
Explain why you think your answer is correct.
Do the following exercises of Section 1.2 in our textbook:
- [4 points] 1.2.10a Use a truth table.
- [4 points] 1.2.14 Use a truth table.
- [6 points] 1.2.24 Use truth tables.
- [2 points] 1.2.40
[4 points]
De Morgan's Laws can sometimes make it more convenient for a programmer to express a logical expression in a computer program. For Java, these laws state that the expression !(condition1 && condition2) is logically equivalent to the expression (!condition1 || !condition2), and the expression !(condition1 || condition2) is logically equivalent to the expression (!condition1 && !condition2). (See De Morgan's Laws also in our textbook.) For example, the following three segments of code are all equivalent:
```
    if (  !(num1 > num2  ||  num2 > num3)  )
        System.out.println("num2 is in the middle");

    if (  !(num1 > num2)  &&  !(num2 > num3) )
        System.out.println("num2 is in the middle");

    if (  num1 <= num2  &&  num2 <= num3 )
        System.out.println("num2 is in the middle");
```
Then consider the following Java expressions:
1. !(x < 4) && !(y >= 7)
2. !(a == b) || !(g != 5)
3. !( x <= 8 && y > 3 )
4. !( i > 2 || j <= 9 )
Simplify those expressions, using De Morgan's laws (etc.) to find Java expressions that are equivalent to those expressions but contain no occurrences of Java's logical NOT operator, "!". (You are allowed to use the inequality operator "!="; it is technically distinct from Java's logical NOT operator, "!".) Acknowledgement: This exercise was derived from "Java: How to Program" by Deitel & Deitel.