[Edu-sig] number-line graphics for teaching arithmetic

[Kirby Urner]

Hi Fred --

Your number line program sounds like fun -- especially for
the person learning a programming language.  For a 7 year 
old, it might be just as instructive to use felt pens or 
colored pencils though.

As mentioned at my "Getting Inventive with Vectors" at 
http://www.inetarena.com/~pdx4d/numeracy1.html , I like to 
go for a more complete vector concept, and not make the number 
line too front and center initially.  Space first, planes 
and lines second, is my approach (take freedoms away later, 
but start with what's most familiar and real i.e. volume).

The way the curriculum is now, we associate numbers with 
lengths, and then take this away later, saying you need 
vectors to extend in space, whereas the real numbers only 
*scale* vectors (are not independently geometric).

So to kids, it seems like real numbers start out acting like 
vectors, but then vectors come along and start doing the 
number line thing like they've already been doing -- but 
now using this new terminology.  Confusing.  Recapitulates 
the historical sequence (Euclid -> Grassmann) more than 
presents a coherent conceptual logic.[1]

The idea of translating a pencil through space without rotation 
should be communicable to a 7 year old.  If it slides around 
in space without change in orientation, that's what we call 
translation (I bet with whole body movements the idea of 
motion without rotation would get across -- e.g. have kids 
slide across the room without changing the direction they're 
facing).

So you have a bunch of these pencils pointing in various directions 
(various lengths too, if you like), and you get to slide them 
anywhere so long as you don't change direction.  Put them 
tip-to-tail and that's what we mean by "adding the pencils" 
(or call them arrows -- then it's just a short step to "vectors" 
-- as a key term).

Here, a computer could be helpful, giving a graphical notion
of different segments adding up tip-to-tail.  It's hard to hold a
lot of pencils in space.  Pictures help.

You could talk about a swimming sea turtle that swallowed a die 
(random chooser device).  At each turn to play, it could pick 
any of the (6) plus/minus XYZ vectors and move in that direction, 
with each hop being a segment (a tail-to-tip interval corresponding
to a pencil in the above discussion):

 >>> import turtles, povray, functions     # Python 101 modules
 >>> myfile = povray.Povray("ocean.pov")   # open a povray file
 >>> seaturt = turtles.Turtle(turtles.xyzrays(),myfile) # xyz freedoms
 >>> seaturt.randomwalk(10)          # take 10 random hops
 >>> functions.xyzaxes(myfile,3)     # add xyz axes to picture
 >>> myfile.close()                  # close file 
 >>> myfile.render()                 # render (or do it manually)

Result: http://www.inetarena.com/~pdx4d/ocn/graphics/ocean.gif
(notice how the turtle back-tracks at one point).

Because these kids start in space, they already know what a 
tetrahedron and an icosahedron are too, and so you can intelligibly
have your turtle swim in one of the 4 directions defined by the 
tetrahedron's 4 vertices (or one of the icosahedron's 12). 
The turtles.py module already defines tetrays and icorays 
for this purpose.

See "Random Walks in the Matrix": 
http://www.inetarena.com/~pdx4d/ocn/numeracy3.html

Once a fully spatial sense is developed, THEN I'd reduce it to 
a single line on which you can only point left or right (or whatever 
we call the two directions (your left or my left?)).  I do it 
this way because I think space/volume is actually more natural 
and easier to understand than these artificially constrained 
"number line" domains.

At this number line level, with degrees of freedom highly 
(artificially) restricted, you could, if you wanted, do some 
simple programming.  Maybe with slightly older kids.  

For example (the methods in action):

 >>> a = arrow(10)
 >>> b = arrow(-5)
 >>> c = arrow(8)
 >>> d = arrow(-3)
 >>> e = arrow(9)
 >>> aprinter([a,b,c,d,e])
  10  ---------->

  -5  <-----

   8  -------->

  -3  <---

   9  --------->

 Result  19 
 >>> aprinter([a,c,d,d])
  10  ---------->

   8  -------->

  -3  <---

  -3  <---

 Result  12 

=========================
Simple source code behind the above:

def arrow(n):
    line=''
    if n<0:  line = '<'
    line+=abs(n)*'-'
    if n>0:  line += ">"
    line += '\n'
    return (n,line)
    
def aprinter(arrows):
    sum = 0
    for a in arrows:
	print "%#3i  %s" % a
	sum += a[0]
    print "Result %#3i " % sum


[1]
http://www.maths.utas.edu.au/People/dfs/Papers/GrassmannLinAlgpaper/node1.html