Unit 2 Lab 3 Teacher Guide

Students build various predicates (examples below) and use them with keep to perform various queries on a list of words to solve a crossword puzzle.
does (orange) have (6) letters? reporting true

does (orange) have (6) letters? reporting true

is letter (4) of (carrot) the letter (o)? reporting false

Predicates are reporters that report only Boolean values: true or false. Students have used predicates with conditionals such as if and repeat until.

Students learn to build new predicates by combining basic predicates (like = or >) with operations like length of or letter 1 of, or the mod block (which reports the remainder when a number is divided by another).
(17) mod (5) reporting 2

Then they learn to combine their predicates into more complex predicate expressions using Boolean operators (and, or, and not), so that they can select list items that meet multiple criteria.

Pacing

Lab Pages

Page 1: What's a Predicate?
- Learning Goals:
  - Formalize understanding of predicates and conditionals.
  - Use relational operators with conditionals to control the colors in a drawing project.
- Tips:
  - If students have trouble with the making the sprite draw only if the mouse button is down but their code looks fine, make sure they have unchecked the "draggable" box above the scripting area (as shown at right).

Page 2: Combining Predicates.

Learning Goals:
- Learn about, use, and interpret expressions with Boolean functions (and, or, and not).
- Develop several versatile predicates: ≤, ≥, ≠, and between?.
- Compare different correct algorithms for the same task (≥).
Tips:
- In English, "or" can be either inclusive (meaning and/or) or exclusive (meaning one or the other, but not both) as the examples on the lab page describe. In computer science, or is inclusive (if either or both of the inputs are true, the result is true), and a separate function, xor (pronounced x-or, for "exclusive or"), is used when two true inputs must result in a false output. Exclusive or is not included in Snap! and is not taught in BJC. Only two (and and or) of the 16 possible Boolean operators are included. Interested students may wish to do additional research on the other Boolean operators (such as nand meaning not (and); xnor meaning not (xor), etc.).
- Technically, an operator is a function of two inputs, like +. Snap! uses the term loosely, so not everything in the "Operators" palette is a two-input function. So, technically, not isn't a operator.

Brian, OK, I went a little over the top here, but some teachers might like to dig in too. Please review this table carefully; it would be easy to get something wrong. --MF, 1/14/20

TG (for answer key): i) The and function can be represented as TFFF; ii-v) Answers will vary for parts ii and iii. The following table lists the 16 (part iv) possible two-input Boolean operators and their usefulness. The goal is for students to think about usefulness—not for them to accurately categorize each of the functions or even to learn the logic of each one. Unless you have a background in logic or computer science, even you (as teacher with the answer key) are likely to find some of these take a bit of thinking to wrap your mind around.

	Useful?	Why?
TTTT	no	always reports `true`
TTTF	yes	equivalent to `or`
TTFT	yes	equivalent to converse implication (false only when the first input is false but the second input is true; the second input being true implies the first input must be true)
TTFF	no	reports the value of the first input regardless of the second input, so you could just use the first input as the predicate instead of building this predicate function
TFTT	yes	equivalent to implication (false only when the first input is true but the second input is false; the first input being true implies the second input must be true)
TFTF	no	reports the value of the second input regardless of the first input, so you could just use the second input as the predicate instead of building this predicate function
TFFT	yes	checks whether two inputs are the same (equivalent to `=` and to XNOR, exclusive NOT OR)
TFFF	yes	equivalent to `and`
FTTT	yes	equivalent to NAND (that is, `not (and)`)
FTTF	yes	checks whether two inputs are the different (equivalent to `not(=)` and to XOR, exclusive OR)
FTFT	no	reports the value of the opposite of the second input regardless of the first input, so you could just use the opposite of the second input as the predicate instead of building this predicate function
FTFF	yes	equivalent to nonimplication (true only when the first input is true but the second input is false; the first input being true implies the second input must be false)
FFTT	no	reports the value of the opposite of the first input regardless of the second input, so you could just use the opposite of the first input as the predicate instead of building this predicate function
FFTF	yes	equivalent to converse nonimplication (true only when the first input is false but the second input is true; the second input being true implies the first input must be false)
FFFT	yes	equivalent to NOR (that is, `not(or)`)
FFFF	no	always reports `false`

vi) There are 256 three-input Boolean operators because there are eight combinations of inputs for a three-input Boolean operator and each of those combinations could report one of two values (T or F):

2^8=256

. (For comparison, there are 16 two-input Boolean operators because there are four combinations of inputs for a two-input operator and each can report one of two values (T or F):

2^4=16

Page 3: Combining Conditionals.
What is this commented out text about? --MF, 5/27/20
- Learning Goal: What is the primary difference between the first two examples of ways to define ≥ (shown below)? The goal of this discussion is for students to see that a good optimization is that you never need to program if some predicate report (true) else report (false), you can just do report (some predicate).
  
  After we finish the standards, we might go back and copy these images and draw circles around the relevant parts in the copies. --MF, 8/15/19
Page 4: Boolean Expression Experiments.
- Learning Goals:
  - Interpret and design expressions using Boolean and arithmetic operators.
  - Practice using and, or, and not.
- Tips:
  - Before solving the problems on this page, students must know that x coordinate goes left to right and is positive to the right of center and that the y coordinate goes up and down and is positive above the center. It's not important to know the precise dimensions of the stage.
  - Consider doing the first two problems with the whole class and then asking what the picture would look like if the and block in the second problem were replaced with or.
  - Picture "i" shows a parabola. Students who recall this curve from algebra may notice that one of the expressions has an ((x position) ^ 2) in it.
  - It's not until rather late on the page that students are told to load the corresponding project. This is because the previous exercises are meant to be done off the computer.
  - Students don't need to replicate the precise coordinates of the change in colors when asked to invent Boolean expressions to generate specific pictures. If they get roughly the right shape, they have the idea.
  - Don't let students get hung up on the use of random positions in the script. That's just a way to get the pattern to emerge visually when only a fraction of all the points have been colored. We could instead have used the script
    
    These images need alt/title text. Brian? --MF, 8/28/19
    
    The "pointillist" pictures look interesting, too.
  - The Take It Further challenges are quite hard, but they'll give students the understanding that this style of painting can produce nontrivial patterns.
Page 5: Keeping Items from a List.
- Learning Goals:
  - Understand that the keep block uses predicates to select items from a list.
  - Practice using keep.
- Tips:
  - Ask students to articulate the basic idea of the keep block: It's a reporter that takes a predicate and a list as input, and it reports only the items from the list that meet the criteria specified by the predicate. The predicate itself must have a blank for the list items to cycle through.
Page 6: Solving a Word Puzzle.
- Learning Goals:
  - Build several predicate blocks by constructing predicate expressions for specific cases first and then generalizing.
  - Use these new predicate blocks to solve a word puzzle.
- Tips:
  - Students may need to be reminded that all the words in the word puzzle are related to AP CSP vocabulary.
  - Students may find the linked Google Sheet version of the word puzzle helpful in keeping track of their progress.
- Resources:
  - Word Puzzle as Google Sheets and as printable PDF.
  - https://crosswordlabs.com/ was used to create the image on the student page. You may find it useful to develop other CS crossword puzzles for students to solve using their predicate blocks.

Solutions

Correlation with 2020 AP CS Principles Framework

Computational Thinking Practices: Skills

1.D: Evaluate solution options.
2.B: Implement an algorithm in a program.
4.B: Determine the result of code segments.

Learning Objectives:

AAP-2.C: Evaluate expressions that use arithmetic operators. (4.B)
AAP-2.E: For relationships between two variables, expressions, or values:
1. Write expressions using relational operators. (2.B)
2. Evaluate expressions that use relational operators. (4.B)
AAP-2.F: For relationships between Boolean values:
1. Write expressions using logical operators. (2.B)
2. Evaluate expressions that use logic operators. (4.B)
AAP-2.H: For selection:
1. Write conditional statements. (2.B)
2. Determine the result of conditional statements. (4.B)
AAP-2.I: For nested selection:
1. Write nested conditional statements. (2.B)
2. Determine the result of nested conditional statements. (4.B)
AAP-2.L: Compare multiple algorithms to determine if they yield the same side effect or result. (1.D)

Essential Knowledge:

AAP-1.C.3: An index is a common method for referencing the elements in a list or string using natural numbers.
AAP-1.C.4: A string is an ordered sequence of characters.
AAP-2.A.4: Every algorithm can be constructed using combinations of sequencing, selection, and iteration.
AAP-2.B.1: Sequencing is the application of each step of an algorithm in the order in which the code statements are given.
AAP-2.E.2: The exam reference sheet provides the following relational operators:
```
=, ≠, >, <, ≥, and ≤
```
.
- ```
a = b
```
- ```
a ≠ b
```
- ```
a > b
```
- ```
a < b
```
- ```
a ≥ b
```
- ```
a ≤ b
```
These are used to test the relationship between two variables, expressions, or values. A comparison using a relational operator evaluates to a Boolean value. For example,
```
a = b
```
evaluates to
```
true
```
if
```
a
```
and
```
b
```
are equal; otherwise, it evaluates to
```
false
```
.
AAP-2.F.1: The exam reference sheet provides the logical operators
```
NOT
```
,
```
AND
```
, and
```
OR
```
, which evaluate to a Boolean value.
AAP-2.F.2: The exam reference sheet provides
```
NOT condition
```
, which evaluates to
```
true
```
if
```
condition
```
is
```
false
```
; otherwise it evaluates to
```
false
```
.
AAP-2.F.3: The exam reference sheet provides
```
condition1 AND condition2
```
, which evaluates to
```
true
```
if both
```
condition1
```
and
```
condition2
```
are
```
true
```
; otherwise it evaluates to
```
false
```
.
AAP-2.F.4: The exam reference sheet provides
```
condition1 OR condition2
```
, which evaluates to
```
true
```
if
```
condition1
```
is
```
true
```
or if
```
condition2
```
is
```
true
```
or if both
```
condition1
```
and
```
condition2
```
are true; otherwise it evaluates to
```
false
```
.
AAP-2.F.5: The operand for a logical operator is either a Boolean expression or a single Boolean value.
AAP-2.G.1: Selection determines which parts of an algorithm are executed based on a condition being
```
true
```
or
```
false
```
.
AAP-2.H.1: Conditional statements or “if-statements” affect the sequential flow of control by executing different statements based on the value of a Boolean expression.
AAP-2.I.1: Nested conditional statements consist of conditional statements within conditional statements.
AAP-2.L.1: Algorithms can be written in different ways and still accomplish the same tasks.
AAP-2.L.3: Some conditional statements can be written as equivalent Boolean expressions.
AAP-2.L.4: Some Boolean expressions can be written as equivalent conditional statements.
AAP-2.L.5: Different algorithms can be developed or used to solve the same problem.

Lab 3: Making Decisions