In this series, we’ve done a review of mathematical notation, with an eye on how each notation helps or hinders student learning. In the previous post, we started to explore function notation, which in middle school and high school shows up as , and examined its use.  This post is a continuation of the previous post.

Let’s continue to look at functions as little boxes that take an input and produce an output, and play with that a bit.  The most obvious way to play with it is to connect the output of one box to the input of another.  An example is shown below:

Two simple function boxes, one which adds three to whatever comes in, and one which doubles whichever comes in.  Together, they take a number that comes in at a and produce a number that comes out at c.  We could hide this entire apparatus (i.e. the combined +3 box and the double box) in a single box, as follows:

and now present it to the world as a single function box with its input at a and its output at c.   The new function box is obtained from the two other function boxes by composition.

Since we know what the smaller function boxes do, we can figure out specifically what the new function box does.  We could try some different numbers at a, and follow them through the boxes at b and then at c.  The value 1 at a will result in the value 8 at c.  The value 10 at a will result in the value 26 at c.  If we collect a whole set of value pairs like this, we can graph them.  We would discover that the graph is linear.

When we don’t know much about the smaller boxes, we need a different approach.  In the picture above, we have two function boxes, labeled and , respectively.   Also notice that we’ve labeled the inputs and outputs again, this time as .  With regard to the function box , we’d say that x is the input and y is the output.  In the standard notation, we write .  Similarly, we write .  Combining both, we’d get .  Yes, in the standard notation, the is shown before the .

We should note that in this standard notation, we need to give a name to the value coming in to the function box.  The function , in standard usage, is pronounced “ef of ex” ( f of x) rather than plain “ef” (f).  This appears to be because in standard notation, the name of the variable x is important; for example, if we say , the name of the variable x shows up again inside of the expression .

Let’s look again at the function box labeled “+ 3″ above.  Notice that it doesn’t contain any variable.  Though we might call the number coming in “x” (or “a” or anything else), the function box doesn’t use “x”.  It just says “+ 3″.   In contrast, in standard notation, we’d talk about the independent variable and the dependent variable , and would write .  It seems like the price we pay for using a “normal” looking expression such as is that we have to commit to the use of a particular variable, here .  And yet, a function defined as is the same function in all respects as the function defined as .  The notion, so beloved in secondary school, that x is always the independent variable and y is always the dependent variable, this gets in the way completely once we look at functions as things that can be combined (composited) easily.

I’m by no means the first one to notice that the “x” in f(x) could just as easily be “y” or “z” or “t”.  The development of lambda calculus in the 1930s gave us a careful and precise model for function definition and function invocation, complete with a system of notation.  This system of notation, involving the Greek letter lambda (λ) has become standard in certain branches of mathematics and computer science.  It makes a clear and precise distinction between bound variables and free variables and elucidate how substitution works, to enough precision so that computers can do it automatically.

All the same, I’d say that lambda calculus is overkill for secondary school, even if introduced only for the notation, e.g. .   I think there are easier ways to make clear through notational means that the bound variable (also called dummy variable) doesn’t matter.  In fact, we’ve already seen examples of it.

Above are shown five identical function boxes, but with different notation.  Box (a) shows the action of the box as an expression, x + 3, and labels the input as x.  The suggestion is that the “x” in the x + 3 expression matches the number on the input.  Box (b) shows the action of the box as an equation, y = x + 3, and labels both input and output, with x and y, respectively.  Box (c) shows the action of the box as a function using lambda notation, and the input is not labeled.  Here, the suggestion is that the label on the input has no bearing on the notation of the function in the function box.  Box (d) shows the function in typical high school notation, using the function label “f” (so the function now has a name, f, even if that name is not used anywhere else.)  Box (e) simply says “+ 3″, suggesting that whatever number is on the input gets three added to it.

Though we might have esthetic preferences for one of the boxes above over the others, it is the use of composition that will really drive up the reasons to prefer one over the other.  Remember that all these 6 boxes are identical inside, and differ only in the labels.  They all add three to the number going in.  I could connect two of these identical boxes, output to input, and achieve the net effect of adding 6 to the number going in:

In situation (a), we see that the two identical boxes need to be given different labels, since the number going into the bottom box is not x, is not the same number as the number going into the top box.  In situation (b), we also need to use different labels for identical boxes, since neither the number going into the bottom box nor the number coming out of the bottom box is the same as those for the box above.  In situation (c), we can indeed use the same labels, since the lambda notation doesn’t presume anything about the name or value of the number coming in.  In situation (d), we could call both the functions f, but can’t consider both boxes defining instances of the function f.  In situation (e), as in (c), we can use the same box with the same label in both places, and have the notation work consistently.

So, for my money, the notation used in situation (e) gives us all the power and grace of the lambda notation while being much simpler for use at the middle school level.  None of the more traditional school notations for functions has the same power and grace once we start to use functions in composition.

My experience with students at the middle school level suggests that the boxes and situations (e) give no problems.  However, we need to examine this approach with examples other than adding constants to get a good feel for how expressive this notation really is.  This will be the subject of our next post.

In this series, we’ve done a review of mathematical notation, with an eye on how each notation helps or hinders student learning.  The focus here is modest: on what teachers can do, even if their textbook sticks to the standard notation, to help disambiguate the standard notation for students.  In the last several posts, we’ve been looking at notations for expressions.

The subject of functions in K-12 is typically only broached very tentatively, gingerly.  Usually, kids learn to associate functions with graphs.  Typically, there may be a situation, which relates two quantities.  For example, a square has a certain side length and a certain perimeter.  As the side length changes, the perimeter of the square changes also.  The perimeter and the side length are related.  This relationship can be shown in a table, shown in a graph, and shown in an equation.

When the side length is 3 units, the perimeter is 12 units.  This is seen in the table as the row 3 | 12,  and it is seen in the graph as the point (3, 12).

Yet when the question is asked “what is the notation for a function” in middle school, that question seems strange.   When later in middle school or high school kids learn the notation , that notation seems to have exactly zero relevance.  Students don’t typically get why saying is in any way better than saying .  And no wonder.  They are told that the stands for function, and it may take years before they ever see others like or .  What functions are not, for these students, are objects that can be held up to the light and examined, and compared to other functions or combined with other functions.  And truly, if all you ever do with is write instead of then there is no point.  Even if students later encounter , it doesn’t seem to relate in any way with the function notation they’ve seen in .

Middle school students and middle school teachers can be forgiven for totally missing out on what’s important about functions at that level, and that is composition of functions.  Composition of functions is a very simple and powerful idea to get a new function from other functions.  For this to make sense, we need to move away from the beautiful and carefully developed notion of a function taught at the college level, which is based in set theory, where a function is seen as a special kind of relation.  Instead, a useful model of what a function is at the middle school (even high school) level is that of a little machine with an input and an output:

We imagine that whenever something (usually a number) is put on the input, something is produced on the output (also usually a number).  It is important that the output can only depend on the input, and on nothing else.  Another way of saying this is that they are state-less: there is no internal state in the box, no memory of what went before, nothing that changes permanently based on what came before.

If we only had a single kind of function box (even if we have a thousand copies of it), the box doesn’t need any particular kind of label.  Even a stupid label like would do fine.  But if function boxes come in all different kinds, we need good labels to keep things straight.  If we know what a particular box does, we should find a way to say so on the label; and if we don’t know (or care) what is in a particular function box, the label should say so as well.

Though we could label function boxes in different styles and according to different criteria, we’d like function boxes to be able to take their place inside of expressions as full-fledged components right next to the My Dear Aunt Sally stuff.  For example, a solution to the quadratic equation, rendered in standard format as  , might look as follows:

where we’ve used simple function boxes for negation(change sign), square (input times itself), double (input times two) and square root.  If you are very familiar and fluent with the standard notation, my sketch above will not have impressed you.  Yet the picture below, showing a simple composition of functions, displays some interesting patterns:

You subtract one from the number coming in, square the result, and then add 5.  If you know the behavior of the square box in the middle – for example, you know the parabolic graph that corresponds to it – then the function box on top tells you to move that graph one over to the right, and the bottom function box tells you to move that graph up 5, resulting in:

In the next post we’ll explore more about composition of functions, how it is useful and powerful, and how notation can help highlight this.

In this post I want to get started on playing with what’s known as modulo arithmetic, also called modular arithmetic, from our framework of operators and equivalence classes and properties.

As a starting point, let’s take another look at the number line.  In this older post, I suggest that this one thing, the number line, takes on a different character as students progress from using it for counting to – much later – locate numbers like π and √3 on it.  When we are just counting, the fact that the numbers on the number line are carefully spaced is not critical – but what is important is that the mark for 4 comes after the mark for 3 and the mark for 5 comes after the mark for 4, etc.  The number line is usually drawn as a straight line, but this may only be critical once we start to use number lines as axes on graphs.

The measuring tapes shown above, whether in inches or centimeters, are essentially number lines also, though they aren’t necessarily straight lines.  If you measure things with them, you probably want to stretch them out to be straight – but if you want to use them for many of the functions you use a number line for, it may be quite sufficient to unroll the tape enough so you can see the numbers you care about.

You could even take a slinky and turn it into a number line.

To do so, you would have to put markings along the rim.  Though the slinky would never be suitable for measuring like a measuring tape, it might serve quite well as a number line.

A sketch of one possible such number line is shown below:

The numbers 1-7 are shown; the slinky extends in both directions, as indicated by dotted lines.  Numbers are shown evenly spaced – in this particular example, precisely 4 whole numbers are placed along each circle.  For example, by the time we get to “5″, we are exactly where “1″ was, just slightly above it.

In prior posts, we’d look at a particular operation, and then decide on equivalence classes based on equal values of that operation, this time we’ll turn things around, and decide on the equivalence classes first.   Can we do this and get away with it?  Sure, if we cast it in terms of: “with respect to what operation(s) will these equivalence classes in fact be equivalent?”

On the slinky number line just sketched, we are going to consider the equivalence classes based on vertical alignment, like this:

Another way of talking about this equivalence is that we consider equivalent all numbers that are 4 apart.  The representatives of these equivalence classes, just like in our earlier posts, are found at the end points of the blue arrows.  So 1, 2, 3 and 4 are the representatives.  There is nothing magical about this particular choice, you can make a very good case for using 0, 1, 2 and 3 as the representatives instead.  We could also have picked -2, -1, 0 and 1.  In a sense, it is too early to argue which make for the best representatives – we haven’t looked at relevant operations yet.

In the next post, we’ll apply this particular equivalence structure to the operations of addition and subtraction.

x

In this post, I’d like to introduce and look at some fairly simple operators (operating on single numbers) that don’t look like arithmetic at all.

The first two act like filters.  The one on the left makes sure that the number coming out is at most 11.  Yet as long as the number going in is less than 11, it is passed through without modification.  The one on the right does a similar thing, but makes sure the number coming out is at least 3.

The symbols used here for each of these filters is intended to evoke the image of the graph of each of the functions.  I like the name lid for the operator on the left, and bottom for the name of the operator on the right.

Here is the graph for our lid function:

and here is the graph for our bottom function:

As simple as these operators may seem, if you try to find operators or functions with these descriptions on the internet, you may be surprised.  In these forms, they are not in widespread use.   Historically, there are two other functions that are in widespread use, min and max, and our bottom and lid functions turn out to be special cases of the min and max functions.  In case you’re not familiar with min and max, min stands for minimum and max stands for maximum.  The minimum of a set of numbers is the smallest of them, and the maximum of a set of number is the largest of them.

The picture above shows a min operator and a max operator, each taking two numbers as input.  Below, you’ll see how these operators can be used to build the bottom and lid operators.

As before, we’ve given the min operator two inputs, and the same for the max operator.  However, one of these inputs is fixed.  The overall effect of a fixed input of 11 using the min operator is that the result can never get bigger than 11, after all if the input is bigger than 11, the min operator will select 11 as the minimum.  If the input to the min operator is less than 11, the min operator will select that input.  (Of course, if the input is exactly 11, the min operator will produce an output of 11, and it could do so by selecting either one of the inputs.)  Similarly, the output of the max operator with a fixed input of 3 will never drop below 3.

If you are like me, these results look backwards and counter-intuitive.  It seems strange to me, at first glance, that the min operator will produce an output that is at most 11, or that the max operator will produce an output that is never below 3.  And yet, they do work as advertised.

So, do we need the bottom and lid operators if we already have the widely-known and accepted min and max operators?  Certainly, the world has survived well without these.  A full answer would have to address both the cost of introducing new notation and terminology, as well as the cost of any confusion when using the min and max operators in the configurations as shown above.

and not only does it produce perfect square numbers, one after another, as the “next” button is pressed, it produces pairs of counter and square (I’m deliberately ignoring the difference component here).  So after a number of “next” presses, we might see

and a little while later

and it might occur to us that if we wanted to find the square of 37, we could hit “start” and then press “next” till the counter showed 37.  This gives us one particularly way of computing the square of 37.  Now, this may not be your favorite way, and it may not be the most efficient way.   And when it comes to computing squares, there are lots of other ways as well.

Yet the idea of generating pairs of values (here counter and square) until one comes by that has the right value for counter, and then looking at the matching square value - this is a general idea that has lots of practically useful applications.  It also allows us a broader take on what a function is.   A number goes in: “37″, and a number comes out. Though it involves operators, it does so in a rather involved way, with twists and turns.  Still – the process is reproducible.  Do the same sequence again, and the same number will come out.

The state machine of the kind we’ve shown here gets us close to the essence of what are known as primitive recursive functions.

We will now show a single state machine that produces the same number pairs:

To make this happen, the state of the state machine consists of a pair of numbers.  As in previous posts, those components of the state are given a name – here exponent and power.  If you follow what happens with the exponent component of the state, you see that it is set to 0 when the start button is pressed, and that one is added to it each time the next button is pressed.  Similarly, the power component starts at 1 and is doubled each time the next button is pressed.  This is consistent with the two state machines in the previous post, and is consistent with the table of number pairs that we are trying to generate.  As you can see, the core operations of the state machine are relatively simple: +1 and × 2; most of the details of the state machine have to do with keeping track of what is being done to what, and what triggers what is done when.

converges rapidly to a value that is the square root of the number in the first box (here 9).  If you changed that number to 25, the state machine would converge to a state of 5, and if you changed the number 9 to the number 2, the machine would converge to a state of 1.4142… This is quite a practical way to compute square roots, and Wikipedia claims that this method was already known to the ancient Babylonians.

In the situations where the repeated pressing of “Next” does not get us closer and closer to a particular value, it is usually very important to keep track of how many times the button has been pushed.

This state machine:

is quite useful to generate powers of 2.  When you hit the “start” button, the state is set to 1, and subsequent presses of “next” will generate 2, 4, 8, 16,…  But how would I use this machine to get me ?  After “start”, I’d have to press the “next” button precisely 20 times.  This is not difficult, but it is very error prone.

Fortunately, counting is itself the process of generating a sequence, and it is a sequence that can be generated by a state machine in a very straightforward way.  This leads us to consider the following:

In this diagram, we have a state machine on the left that generates a counting sequence: 0, 1, 2, 3, …; and the powers-of-two machine on the right that generates the sequence 1, 2, 4, 8, …, and the idea is that we can couple these two machines, so that they move in sync with each other.  We might think of a big Start button that, when pressed, causes both of the start buttons shown to be pressed, and a big Next button that, when pressed, causes both of the next buttons to be pressed.  When the two machines are coupled this way into a single machine with two screens, we can think of the states as being coupled also.  On hitting Start, the screens show 0;1, after hitting Next we see 1;2 and after hitting Next again we see 2;4.  No matter how often we hit the Next button, the state of the “+ 1″ machine will always indicate how many times we’ve multiplied by 2 in the “× 2″ machine.  Another way of saying this is that when the state of the “+1″ machine is , the state of the “× 2″ machine is .

In the next blog post in this series, we’ll model the same behavior using a single state machine.

The idea is that we have a device with two buttons and a screen; after we press the Start button, we can press the Next button any number of times, and we see a sequence of values play out on the screen.  Though the Start value is important, the fundamental structure of the sequence of values comes from the nature of the operator invoked by the Next button.

In this post, I’d like to show how such sequences can be simulated in a spreadsheet.  There are many ways to do that; I’ll just show one:

In this spreadsheet, the “state” column represents the sequence of states the state machine goes through.  For each state, the value in the “next” column indicates what the next state will be.  The formula for the C2 cell is shown: =B2+3.  That tells Excel to take the value of the current state, in B2, and add 3 to it.  The formula for the B3 cell is not visible in the picture, but it is very simple: =C2.  The new current state is the old next state.  All the cells below B3 get their formula simply from copying and pasting the content of B3.  All the cells below C2 get their formula from copying and pasting the content of C2.

Similarly, we can make a spreadsheet corresponding to:

and this is shown below:

where you can see the Excel formula used for the cell C2 – it matches the operator even if the notation is different: the notation is adapted to Excel’s needs and conventions.  The formulas for the cells below are again simply copied and pasted from what is in C2.  The cells in the B column are identical to those in the previous example.

You may notice that this state machine has some very interesting behavior: once the state of the state machine settles on the value “3″, then the next value of the state is also 3, and from that point on, the state will forever remain 3.  This behavior is often called “steady state” in physics, and is often called a “fixpoint” or “fixed point”  in mathematics.

What is especially interesting about this spreadsheet is that the steady state isn’t even particularly dependent on the start value:

Here, we use the exact same formula as before, but we used a starting value of 10 – and still got to a state of “3″ in just a few steps.  If you have access to Excel yourself, you may want to play with different starting values, and observe the behavior.  Do you always end up with a steady state (or fixpoint)?  What range of starting values will lead to this fixpoint of 3?

What I would like to do next is to apply the state machine model to what are sometimes called sequences, sometimes called series, and what are known by others as recurrence relations.  Most of us are familiar with the type of question: “what is the next number in the sequence 10, 13, 16, 19, …?” where you are supposed to notice that the numbers n the sequence are each three higher than the number preceding them.  All this relates directly to the state machine model we’ve been using:

If the state of the machine is just a number, and the button is labeled something like “Next”, then a starting state of 10 and an operator of “+ 3″ will match the behavior of the sequence  10, 13, 16, 19, and pressing Next one more time will get us a state of 22.  This is shown below:

You’ll notice I’ve also added an explicit “Start” button, so we can reset the thing, and it also gives us a way to show the starting value in a static representation so we don’t have to rely on a video of the thing to see what the starting state was.  What I haven’t made explicit, but assume, is that the state is shown on a screen so we can see what the state is.

I’ll leave you with some teasers, to be followed up on later.  Can you see what the behavior of each of the following machines is?

To refresh on notation, in the second one of these, we use the notation “10 -” for “subtract from 10″, and in the third one of these, we use the notation “9 ÷” for “divide into 9″, as we introduced here.

In prior posts, I used the Collatz Problem, restated here:

Each counting number n past 1 is assigned a successor number, as follows:

The number “1″ is considered home, and when you’re home, you stop.  If you start at a given number away from home, and cycle through its successors, you may end up home.  Is there any starting number from which you will not eventually reach home?

The Collatz Problem, still unsolved, intrigues me in that it is so simply stated and yet so very deep.  It’s also a very well-balanced problem in the sense that many simple variations of it can be solved at the K-12 level.  Here are some of those variations, offered as a puzzle:

A. Each counting number n past 1 is assigned a successor number, as follows:

The number “1″ is considered home, and when you’re home, you stop.  If you start at a given number away from home, and cycle through its successors, you may end up home.  For what starting numbers will you eventually reach home?

B. Each counting number n past 1 is assigned a successor number, as follows:

The number “1″ is considered home, and when you’re home, you stop. If you start at a given number away from home, and cycle through its successors, you may end up home. For what starting numbers will you eventually reach home?

C. Each counting number n past 1 is assigned a successor number, as follows:

The number “1″ is considered home, and when you’re home, you stop. If you start at a given number away from home, and cycle through its successors, you may end up home. For what starting numbers will you eventually reach home?

D. Each counting number n past 1 is assigned a successor number, as follows:

The number “1″ is considered home, and when you’re home, you stop. If you start at a given number away from home, and cycle through its successors, you may end up home. For what starting numbers will you eventually reach home?

Note that in each of these we’ve left the treatment of even numbers alone, and yet get very different behaviors. The treatment of odd numbers in the original Collatz Problem is one where you can neither find an obvious counter example nor a straightforward demonstration of why you always reach home.
However, the 3n+1 formula is not unique in this. There is at least one other treatment of the odd numbers that is essentially equivalent to the Collatz problem (in the sense that if you solve one, you’ve also solved the other one.)

E. Can you find a treatment for the odd numbers (leaving the n/2 treatment of the even numbers alone) that creates a problem equivalent to the Collatz problem?