The function concept is sometimes said to be pervasive in school mathematics - although it is not until secondary school that it is formally introduced, many elementary school math math activities can be thought of as preparing the way for understanding and working with functions.

However, few students, or teachers, ever make a connection between the functions that they eventually learn about (or teach) in high school and those implicitly encountered in early primary grade activities.

Take for example, the symbol patterns that grade one (and kindergarten) students are often asked to look at, like this one:

Given such a pattern, students are often asked to describe the pattern, continue it, or identify its "core-pattern" or kernel - the repeating unit within the pattern.

How are patterns like this related to functions? Or how do we model such a pattern using functions?

Any sequence of symbols can be thought of as a function from the natural numbers N onto a set of symbols S. You can show this mapping by simply labeling the pattern with N.

So, the pattern can be thought of as a rule

*f*that associates a symbol with each natural number. That's nice, but how can you represent the "rule" that determines which symbols appear where? One way is to return to the core-pattern idea, which reminds us that our pattern is cyclical. In this example, it is a 4-cycle, which you might visualize as a sort of loop among four vertices, or maybe as a clock with 4 positions:
A nice function, sometimes introduced in school math, that maps the natural numbers onto this kind of structure is the

*modulo k*operation. In this case "modulo 4" is what we need: for any natural*n*,*n*modulo 4 returns the remainder of*n*divided by 4, which is always one of the numbers 0, 1, 2, or 3. Modular arithmetic is sometimes called "clock arithmetic" because it is cyclical, and the function "modulo 4" can be visualized as wrapping the number line around a clock with 4 positions on it. So let's say that*h*is the function that maps N onto the set K={0,1,2,3} following the rule that*h*(*n*) =*n*modulo 4. It's graph looks like this:
Now consider another function

*g*that maps the set K onto the symbols in our set S, it's*co-graph*looks like this:
The overall pattern can be described as the composition

*f*=*hg*, and perhaps visualized as a clock labeled with the symbols from the pattern. This shows both the cycle that defines the pattern (the function*h*) and the arbitrary association of this core-pattern onto particular symbols (the function*g*), so I think this is a pretty nice way to represent the pattern in terms of functions, but there are other possible descriptions.
So what's the point?

Well, it's fun to do this sort of thing isn't it?

I think it is worthwhile thinking about why we don't often look back and apply the language of functions to early (very early!) math. This may be in part because, as described in the Common Core Standards, "In school mathematics, functions usually have numerical inputs and outputs and are often defined by an algebraic expression." Here we have a non-algebraic function that has a non-numeric output. So, although we do eventually learn about and teach functions in school, they don't tend to be the kinds of functions that lend themselves to talking about the patterns, sortings, colourings, etc. that are encountered in elementary school.

Although this whole thing may seem weird from a school math perspective, it might seem more natural to think of the pattern this way if you are used to thinking like a programmer, and were trying to find a way to generate patterns like this. The pictures in this post, for example, were made in Fathom using the idea of the two functions

*g*and*h*:
Another thing you might ask: in doing this activity, did we "uncover" the functions that lie behind this simple elementary school patterns, or did we "model" the pattern using functions? I would probably say that we used the language of functions to make some of the underlying structure more apparent.