Getting There, and a contender: Mathination

Hi all,

This Saturday Joe and I will be doing a demo. Check out
the current release at http//touchmath.dyndns.org/demo/demo.html.

These are the current features:
- *, /, +, -
- swapping additive groups
- swapping multiplicative groups
- limited evaluation

These just need a few touchups and the core math is finished.
We'll be improving these with some multi touch gestures and
keyboard input for the desktop. The next step will be getting
this out to some people to play with.

If you've been reading, we've shifted plans. Earlier this week
we discovered that, on the 15th of October, Matthew Self published
his iPad Mathination software.
We haven't played with it yet, but it looks quite good. Kudos to
Matthew Self for releasing first viable contender in the touch-math space.
This is exactly what we had in mind at the start of our project in September.

Before discovering Mathination, we were gearing up to abstract our
tree manipulations to a more functional approach that decouples
operators from code, and lets you define new operators without writing
more code.

But this will have to wait for now. Matthew Self's project puts some pressure on us to get basic algebra finalized ASAP. And I feel confident that we will bridge this gap, pending aesthetics, just momentarily.

Once we do this, we're interested in getting this software out to people learning and teaching algebra. They'll want prepared problems, history, and hints.


Thanks for reading,
Alex

PS you can see it in action here: http//touchmath.dyndns.org/demo/demo.html.
And you can pull the code here: github.com/adc/digiti

Today's Presentation

Hi, Alex here.

Today we hit our second presentation.

After giving up on our prezi, we decided to jump to demo. Joe passed around his iPod touch and showed people the demo on the projector, and walked them through the features.

Here are a few quotes:

Alex (confused): "Why are you guys laughing?"
RCOS "It's cool!"

Alex : "And , I'd like to than Joe. Work with a math major! They make good partners"
Joe (CS) : "I'm not a math major!"


We got TONS of feedback, and we really appreciated the interest and enthusiasm. It feels to me that the project is on the right track.

Okay so before we had this: http://touchmath.dyndns.org/demo0/canvas_test.html.
It looks okay, but it's pretty awkward and has a bunch of errors. Joe fixed fixed all of this with his grouping implementation: http://touchmath.dyndns.org/demo/demo.html. Check it out. This is really nice!

This definitely makes my week. Way to be

Feedback
- Add a history! (Brendan Ashby)
- It'd be great to add recursion operators! (Genesis emulator dude)
- Add calculus, limits, summations (Peter Hajas)
- Add diffeq! (Graylin)
- You should get some users. See what younger kids think (Moorthy)

Minor fixes that should be done:
- improved parenthesis
- cleaning up "1"s in division and multiplication
- adding exponents

Major things
- evaluation?
- new gestures
- generators for resolving equations

Doing things smarter

Ok, so we have a basic thing going. Soon enough gestures for multiplication, division, and factoring will be in.

Right now they're being done on a case-by-case basis though. That's not too good. It's really bad actually. Instead we should be doing all of this with a solver.

A solver is something that recursively applies algebra rules until it reaches a desired form. Here's a link to javascript->prolog (http://ioctl.org/logic/prolog1). That's basically all we need.

This is really a math problem, which declarative programming can be rather good at. So what should queries look like?

Part of the difficulty is just identifying what needs to be solved. The user makes some gestures involving different symbols. For simple additivity this is taking a symbol, a for instance, and trying to get it on the other side of the the '=' operator.

So, a recursive solver would just start going through possible operations on a that may lead to this. A Prolog-like approach would be especially good, with cuts and all that jazz. But aah, that link doesn't have cuts. hMmmm. But, what's this? OMG http://yieldprolog.sourceforge.net/
That looks quite promising. As does this project. Awesome!

Addition

Hi,

A basic proof of concept Joe and * made is floating online.

Currently only addition is supported. We're still thinking up the gestures for dealing with products and divisors.

Joe has also gotten Safari Mobile compatible event recognition going over here: touchmath.dyndns.org/movement_test.html . On the todo list is abstracting our javascript events for supporting loads of different html5 capable browsers and devices.

To use the interface, input an infix expression. It gets converted into an expression tree. And as you manipulate symbols in the infix equation, the underlying expression tree readjusts to match what you're doing. If the tree doesn't like what you're doing, syntactically or algebraically, it will resist the change. Otherwise it will give you the go ahead.

Once products are together, we'll add in exponents, then combine the blocky shapes into a more aesthetic form.

One thing to note at the moment is that the algebraic expression manipulations are not very formally defined. This is something we're saving for a second iteration through this stage. As an end of semester goal we're looking to fully support +,-,/,*,^, and parentheses. These are pretty trivial, and should not require a highly formal approach.

As we prepare for adding in calculus and other cool math, the semantics become more complex. It'd be great to create some grammars that can take care of all these things

Some dangling thoughts and questions for our readers:

1) Currently, we're not using any libraries. Are any out there recommended? Should we use prototype.js? JQuery? What about building a desktop app with node.js?

2) There doesn't seem to be a mouseUp event in Safari's mobile touch...whaat

3) Any good papers on computer aided interactive algebra?

Thanks,

Alex & Joe