The Last Presentation of the Year

Hey,

So we gave our final presentation of Touch of Math last Friday. You can see the Prezi (which worked this time!) at http://prezi.com/wogbvom-nhxy/touch-of-math-2/ and our latest code can be tested here: http://touchmath.dyndns.org/multitouchdemo/demo2.html

So the presentation, I'd say, was a success. Most of the algebraic math is there, there's just a few small kinks to work out. We also introduced our newest feature, merging, which gives us some evaluation methods. We hope to build on this as much as we can.

As last time, we got several more ideas to implement, including a history, higher order math, etc. They're all excellent ideas, and once we do some more bug-fixing, you'll start seeing them worked in.

Also, next semester we may have another developer working with us to help with our front end stuff. I don't want to say too much more about it, since nothing's final, but I'm really excited to work with him in the Spring.

That's all for now, we'll keep you posted through the winter of anything new going on with Touch of Math.

- Alex and Joe

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

Some Basic Features

David Doria had some great feedback after last Friday's presentation. Here's a list he put together of things both he and us would like to see ASAP

1) Addition Balancing

Initial state:

A = B+ C

Final state:
A - C = B

2) Multiplicative Balancing

Initial state:
A = B C

Final state:
A/C = B

3) Expand (distributive property (additive and multiplicative))
Initial state:
((x-2)*(x-4))

Final state:
x^2-6*x+8

4) Factoring (inverse of 3)

After last Saturday's meeting, we're sort of close to achieving this right now. More posts coming after today's session

A Smart EQN Interface

Joe LaBarbera and Alex Rad here, we'd like to welcome you to the decade of multitouch.

Working for the Rensselaer Center for Open Source, we'll be designing and building an interactive equation interface. The idea is to augment human mathematical abilities with software that both expands educational capacity and greatly improves analysis capability.

For education, calculators can be a mixed blessing. On the negative side, some students tend to become overly dependent on the analytical capabilities of the more capable hardware. This can utterly destroys their mathematical abilities. We're hoping to make something where this just isn't an issue.

The design behind a really smart equation editor is a also a bit different than your normal form-based formula editor. W're trying to augment, not replace, human analytical capability. Rather than writing on a piece of paper, a user can manipulate symbols on a screen. And with the advent of multi-touch capable devices, these manipulations will match and possibly surpass the intuition of a pen.

For more information check out this poorly put together presentation Alex Rad made last Friday here.

Thanks,

Joe & Alex