[Edu-sig] ET Math (doors to alternative realities)

[Kirby Urner]

>your thoughts most welcome
>- Jason

I agree that prefix notation (+ 1 1) vs. infix notation (1 + 1) is 
something of a curve ball for most of us.  

That's why I'd do some work to introduce it earlier, perhaps by booting 
DrScheme on a classroom projector.  "Look folks," I'd say "we all get 
used to a = 1 + 1 from our text books, but you should realize that's 
cultural, and a serious alternative, actually used in some computer 
languages, would go like this (define a (+ 1 1)).  Note that 'define', 
which plays the role of '=', is likewise a prefix -- very consistent."

This comes under the heading of "ET Math" or "Math from Mars" in my book 
-- a sort of genre I work with.  The point is to give insights into math 
by showing "what could be different, and still be of utility to an 
intelligent life form".[1]  

I do something similar with coordinate systems, showing an apparatus that 
uses 4-tuples of non-negatives to map ordinary volume (similar to XYZ 
in other words) -- a gizmo I call "the quadrays coordinate system" and 
have researched with colleagues.[2]  

Another game is to show how triangles and tetrahedra make fine models of 
2nd and 3rd powering respectively, so we could be saying "3 tetrahedroned 
= 27" instead of "3 cubed = 27".[3]  Again, we're brushing up against a 
whole other paradigm, an "ET Math" if you will.

In other words, I think this prefix vs. infix discussion presents a 
great opportunity to open a door, expand the mind.  

That being said, we don't necessarily have to go through the door 
and spend the whole semester there.  For kids encountering all this 
stuff for almost the first time, it's all pretty alien, and too 
many alternatives all at once can be too disorienting -- so I think 
we should walk a fine line.  Open a lot of doors, but don't try to go 
through them all.  Leave them for later -- you can come back to this 
stuff.

I'm thinking Python might be used to open a door to Scheme.  Instead
of the usual thing, of putting two languages side-by-side and showing
how different they are, we can modify our style of coding in Python
to make it appear more Scheme-like.  We can write recursively, for 
example, and do some functional programming kind of things.  

For example, you can define car and cdr of LISP fame:

 >>> def car(mylist):
	if len(mylist)==0: return []
	else: return mylist[0]

 >>> def cdr(mylist):
 	 if len(mylist)==0: return []
	 else: return mylist[1:]
 

Usage:

 >>> car([1,2,3,4,5])
 1
 >>> cdr([1,2,3,4,5])
 [2,3,4,5]

In Scheme:

 > (define mylist '(1 2 3 4 5))
 > (car mylist)
 1
 > (cdr mylist)
 (2 3 4 5)

Then we can do something recursive like this:

 >>> from operator import *

 >>> def Reduce(operator,mylist):	
       if len(mylist)==1:  return car(mylist)
       else: return apply(operator, (car(mylist), Reduce(operator,
cdr(mylist))) )

 >>> Reduce(add,[1,2,3,4,5])   # = (+ 1 (+ 2 (+ 3 (+ 4 5))))
 15
 >>> Reduce(mul,[1,2,3,4,5])   + = (* 1 (* 2 (* 3 (* 4 5))))
 120

Note that I've named this Reduce, not reduce, which is a built-in, and 
gives the same results:

 >>> reduce(add,[1,2,3,4,5])
 15
 >>> reduce(mul,[1,2,3,4,5])
 120

Although Scheme purists might have little patience for such stuff, I think 
this helps communicate some of the flavor of Scheme to those more familiar 
with Python.

In sum, even if going with Python as a first language, I'd open a door
to Scheme via introducing prefix notation, and would lay some groundwork
in Python (as per the above example) for latter tackling Scheme and 
similar languages.

Kirby

[1] more re "ET Math": http://www.teleport.com/~pdx4d/amtepost2.html

[2] http://www.teleport.com/~pdx4d/quadintro.html 
    (links to Python implementation in 'For further reading')

[3] http://www.rwgrayprojects.com/synergetics/s09/figs/f9001.html