Lately, I’ve been thinking a lot about mappings–particularly the kind of mappings we make across mathematical representations like algebraic notation.  Part of this is to build toward a cluster of automated mapping systems that allow for flexible enforceable mappings across structures–I’ll write about that project later.
Here, I’m just going to muse a little bit on the difficulty of pinning down some analogies that are very common in math classes, yet on their surface seem challenging for mapping processes (at least, the ones I know of) to handle.  I’m going to talk just about number lines and arithmetic notation, but the same points seem to hold for a wide variety of situations.

In case you don’t know, this is all part of a bigger program of mine, which involves aligning cognitive science research on relational reasoning to the kinds of activities that go on in mathematical contexts, from middle-school to professional situations.  In this article, I’ll talk about cases in which one representation is mapped into another, in order to gain some intuition about their common structure. This is different from a case in which one representation is used merely to present some numbers or information about another situation, like when making a graph (and so I won’t be talking, for instance, about the kind of graph reading problems that Steve Franconeri often focuses on).  Familiar examples of the kind of thing I mean are alignments of repeated addition and multiplication, pebble-counting and the natural numbers, 2-dimensional xy-graphs and functions, force diagrams,  and symbolic notation used to solve story problems.

First, let’s articulate what the preferred scenario would be like.  We have many  good mapping algorithms from cognitive science, like SME, SIAM, DORA/LISA, and so on, each of which has a its own ideal domain, but all of which satisfy a common set of constraints.  in particular, all of them are intended to conform to one-to-one mapping constraints, type constraints, and some kind of systematicity such that (a) higher-order relations matter more than lower-order relations, and (b) when relations map so do their arguments.  in our preferred situation, it would be easy to take those algorithms and apply them to the kinds of mappings prototypical in math classes.  We’d identify element types and relation types in each context, and build the best analogy from one to the other.  Then, in any particular situation, we’d use our type mappings to re-identify the tokens of one situation in the other.  Easy peasy.

Some complications in this scheme are immediately apparent at purely a theoretical level.  First, the relations that constrain a situation–and thus then constrain the best mapping–may be arbitrarily far from the representation you’d like to have them in.  For instance, in the case of graphs, some constraints result from physical properties of the paper you use (or anyway, the implicit structure of 2-d geometry).  Just as perniciously, they may result from rules that are stated, but are stated using assertions that are arbitrarily far from the representation you’d like to have them in for making any particular mapping.  For instance, a BNF parser for algebraic expressions will look very different than the kind of relative binding strength model most typically employed in visual perception, so aligning such a representation with the outputs of visual systems would be arbitrarily challenging.

Other problems are more pernicious.  First, many or most analogies in mathematics do not obey these constraints.  As an easy example, consider homomorphisms from the Klein 4-group onto itself.  Some of these are genuine isomorphisms, which make for good analogies.  However, the simplest mapping is one in which each element of the group maps to the identity element. The result is a (degenerate) group, but with a 4-1 mapping.  As Dirk Schlimm has pointed out, many mappings in mathematics are not one-to-one under the natural interpretation.

Just as bad, many of the best maps don’t obey type constraints–in fact, violating type constraints is one of the basic powerful things that mathematical notation does.  Math is chock full of cases in which we turn relations into objects (e.g., in the notation itself, or in the kinds of dual-interpretations of arithmetic expressions Anna Sfard has talked about), or objects into relations, or functions into curves, and so on.  Going back to the 4-group, we can consider the set of automorphisms from the 4-group onto the 4-group. There are 6 such automorphisms, which are equivalent to the permutations of 3 elements.  Now, I can naturally think of these automorphisms as actions or relations, but I can also recast them as objects–this is what we do all the time in mathematics.  Even just thinking about the 4-group itself, Erik Weitnauer points out that the typical symbolic notation (confusingly, if you’re not used to it) identifies operations and states, so that taking the B action puts you in the B state (if, and only if, you were previously in the identity "state").

But things get much sloppier than this, and do so in cases that are stone simple and ubiquitous in elementary school classrooms.  Let’s consider some mappings between pebble piles, number lines, and arithmetic notations like 5+5.  The easiest case is the notation: there are 3 elements in it: the two fives are distinct but identical tokens, the + is non-identical. The relations are all spatial relations (e.g, the leftmost 5 is left of the +, while the other is right of it)*

5+5

So far, so good. Things already get messy when we consider a pebble model, but not too bad.

Here we have two sets of pebbles. We can count them separately, in which case their result is 5, or we can count them together, in which case the result is 10. This is somehow supposed to help us understand what "plus" means. We often find it intuitive to think of plus as the act of ‘putting the pebbles together’, but a moment’s consideration will convince us this is not the whole story–in fact, two pieces are missing. After all, I can dump these pebbles in a pile together, and still count just the purple ones.  On the pebble-counting model, arithmetic operations reflect a change in the boundary condition of the count process, not a spatial transformation.  It just so happens that human perceptual grouping mechanisms that form the core of actual counting tend to effect boundary condition changes through spatial transformations, which is what makes the usual move work.

So on this model, we really have 10 objects: each pebble. We have a set of spatial relations–most relevantly proximity relations, but also left-right relations.  The natural mapping is a 5-1 mapping, in which the first object in the arithmetic case maps to the 5 green pebbles (or to the group of pebbles), the righthand five to the group of purple pebbles, and the plus object maps to the dispositional fact that transformations of counting boundary conditions conform to the Peano axioms**.  Wait, what?

But that’s what it is: the plus sign maps the endogenous act of transforming boundary conditions.  The 5 maps to an individually counted 5 set; the other 5 to another; and the plus to the newly considered situation.  If you prefer it, you can think of the whole 5+5 group as mapping to the entire set of 10.  This makes the mapping even less one-to-one, but I want to focus on the fact that the numerals each map to piles, while the other object–a plus, maps to a dispositional fact about count procedures under transformations.  This sure seems like a violation of type constraints, of the sort that LISA and SME really, really, really don’t like.

Let that go, though.  Not because it shouldn’t worry you, but because other things should worry you more.  Like the number line.

 

Here’s a quote from Tutorvista that explains how this is supposed to work.

Solved Examples
Question 1: Add: 6 + 3 using number line

Solution:
Given: 6 + 3 In normal addition the answer is 9. Now we use number line method for addition of two integer numbers. Here the starting point is 6. The 3 is a positive integer so we move to forward in 3 steps. Now we get the destination point. So the 9 is an answer.

So, on the "normal interpretation", you have a mapping from pegs to the naturals, and a number to a peg. So the expression "5″ is mapped by being at the 5 spot. So if you have 5+5, the analogy is to starting at the 5 peg, and moving 5 pegs to the right. You can then "read off" your location by identifying the peg you’re at as a result (the "10″ peg).

Of course, this works fine for getting answers–but it plays hell with typical notions of analogical mapping. Notice that we just mapped the left and right 5 elements–identical in the arithmetic notation–onto totally different kinds of things  in the number line: the left 5 is mapped to a peg, while the right 5 maps to an action–the act of moving 5 pegs.  But moving 5 pegs and the particular peg marked 5 don’t seem to be the same sort of thing, or even to have much in common.  The + is even worse, because it also seems to map to the action–it specifies that the moving is rightward, not leftward (or something more complex).  This + acts more like an adverb than an object–it modifies the character of the action specified by the 5.  So to sum up: in the arithmetic case we have three objects, with spatial relations. In the number line case, we have an object, a action, and a characteristic or manner of that action. Yick.

I’ll leave the task of aligning pebble-counting and number lines as an exercise to the reader. It is a fairly daunting task as well.

Resolutions

There are really only two ways out of this mess that I can see. One solution–the one that has been most pursued in the analogy literature (usually under the label "re-representation")–is to abandon the natural interpretation, and look for interpretations that align the entities better.  In our number line case, we can actually improve things somewhat by abandoning the idea that a singleton expression corresponds to a peg.  Instead, we can make a new kind of number line situation in which we always start at 0, and have to move to each peg as we go. On this interpretation, a singleton like "6″ actually means "start at 0, and move six to the right".  It’s very natural in such a case to see "6″ as implicitly "+6″, and to treat operators as unary rather than binary.***   After this kind of representation, we do indeed get a slightly better mapping, in which pegs have no interpretation, bare numbers are treated as having implicit + signs, and +n pairs are treated as motions, with the sign indicating the manner and the n indicating the extent (number of hops).  Still many-to-one, and it still maps objects onto both actions and manners, but at least each entity type has a consistent interpretation****.

The trouble with this solution is that I can’t think of any reason to believe that people do it–at least not much.  Instead, people seem to make very sloppy, ad hoc maps that work, and to use them in ways that involve what look like deep inconsistencies.  This fact may make learning these systems harder (and often number lines are initially taught starting from 0), but it seems to be how things work out in use.  People move very smoothly between thinking of pegs as numbers, and thinking of actions as numbers, without being in the slightest bothered by the type constraint violations they are engaging in. Rerepresentation theories generally hold that we find a description on which these things are consistent, but it’s hard to see any non-circular reason to think we actually do.

There is one alternative that I think is worth trying out. Mathematics may be simply more pragmatic than we’d like to think it is: what matters might be not alignment of parts of static states at all, but rather consistency across dispositional transformations in general. More prosaically, as long as a mapping ‘gets the right answer’, and as long as it does so necessarily in virtue of something (under some possibly constrained range), then it’s a valid mapping.  This is consistent with the kinds of theories I’ve been coming up with about mapping quality being based on successful outcomes, or that Matt Jones and James Foster have been developing out in Colorado.

On this account, one job of the mathematician is sometimes (not always!) to figure out why a particular mapping works–that is, to decide what kinds of entities are being mapped in some particular case.  The regular user of a system, on the other hand, doesn’t care.  As long as transformations of structure A map lawfully into transformations of structure B, and answers maintain consistency, the whole thing gets to proceed, even though it lacks static consistency.

In the specific case of number lines and arithmetic, I have something like this: I have a consistent way of labeling my pegs, and my actions (a 2-1 mapping, to be sure).  And I have rules, like

"If I have a number, be at that peg.  If I have a sum, start at the peg of the leftmost number, and move as specified by the action mapping of the other numbers. The end peg is the solution to the computation".

This is natural, easy to specify and follow, and (this is important) it’s a good analogy in that results map to results.  That is, all the analogical inferences work.  But (and this is important too), the static mapping of states of the arithmetic expression don’t map at all cleanly to the states/actions in the number system.  The number line involves at least one ad hoc blending of two conceptual distinct and incompatible mappings; the only justification of that blend is that it works to get right answers.

This flips the usual analogical reasoning on its head.  Instead of prizing a sound mapping, and allowing that sometimes inferences will fail, on this conceptualization of mapping in mathematics, we prize sound inference and drop the idea of high-quality mappings.

Curious.  I should mention that all this thinking is in the service of the construction of an algorithmic ‘mapping’ GUI, who’s goal is to make mappings across mathematical representations easy for students to construct, easy to test, and highly visible–that is, to render mappings as inspectable objects rather than abstract belief states or perceptions.   More on that in another post.

* Notice that I’m not going to make this easier by ‘interpreting’ the symbols for you. There’s a lot of reasoning that gets packed into this process: (a) it’s not clear how any of it is accomplished, and (b) for many purposes (like parsing) we need to treat all these elements as objects, so we won’t cheat by assuming away part of the work.

**And, somewhat more strongly, the constructions of naturals through set theory.

***This is what grasping math already does, just in the arithmetic domain.  It leads to some other troubles down the road, but we can ignore those for now.

**** in case it’s bothering you that the pegs are meaningless, they do play a role in equation statements.  The analog to 5+5=10 is that if you move 5 right, then 5 right, from the start peg, you end at the same peg as if you just move 10 right.  So even though the pegs don’t correspond to numbers, they do specify constraints on equation relations.