bidicalc: a bidirectional calculator
72 points by victorpoughon
72 points by victorpoughon
You might be interested in an abstraction called "propagators". They're like hypergraphs where the nodes are bounded join semilattices holding information, and the edges are monotone functions from the input nodes to an output node. If you're careful you can make e.g. your arithmetic operations build propagator networks so you have a shot at running computations "backwards" and deriving "inputs" from "outputs".
That's so interesting because propagators are a big part of how bidicalc works already, but I had never heard of them. This is because I read about them not in a functional programming context, but in a math book where they are called "contractors" instead. I suspect there is a lot of overlap but also subtle differences!
It's always fascinating when this happens. There might even be entire research groups out there that don't know about each other but are working on the same thing!
FWIW the link to the thesis throws a 403
For some useful prior art in this space, see relational language( familie)s like miniKanren.
“Hello, declarative world,” by Tom Stuart is a pretty useful introduction, and includes a reasonably-complete implementation of microKanren.
All the best,
-HG
Excel has Goal Seek and Solver which work similarly, with a variable recalculation iteration limit.
I remember using Excel in university to design a glow stick factory, where the goal was to recycle unused reactants to maximise efficiency - you could route the “byproduct” cells back into the “input” cells and recursively calculate the maximal output!
Was my first introduction to “constraint” programming (later got introduced to MiniZinc) and never looked back :)
Interesting, I wonder if I can use this to solve this year's Advent of Code puzzle for day 10...
Yes, day10 was very well suited for solving with constraint programming. I did my solutions in MiniZinc, solving the problem for each instance and then summing the results separately.
The "standard" MIP/CP style formulation for day 2 is short, and is solved quite quickly. Solve times per instance are on the order of 0.01s for Gecode, OR-Tools CP-SAT and HiGHS, while the MiniZinc translation took around 0.1s per instance.
I find this really cool but can’t think of a case where it’d be useful to me. Tell me your ideas!
Lots of scientific equations involve lots of equation juggling with multiple unknowns, I definitely would have liked this in grad school. Simpler for small things than WolframAlpha and less tedious than doing the equations by hand and plugging them into Python.
I was curious how it handled trigonometric functions, as they're periodic so anything propagated backward has infinite possible values. But they seem to almost immediately break, Set:
A1 = anything
B1 = cos(A1)
Then update B1. It will display "No solution".
It should work if you set B1 to something between -1 and 1, which is the range of cos. But you are right that trigonometric functions are an edge case. I debated even including them at all because of this. Currently the implementation is sketchy and you can definitely break it with trigonometry functions in funny ways. Still it works for simple cases so I've decided to leave it in for fun.
Ah, I was mistaken in the bug.
It breaks if A1 is an expression more complicated than a simple constant. I was using multiples of pi(), and had assumed it would simplify it to a floating point number.
Try this though:
A1 = 1 + 1
B1 = cos(A1)
Then modify B1.
Yes this intended. Your example doesn't have any free variables so it can't be solved.
Neither does A1 = 1, B1 = cos(A1). But that works fine.
Rather than free variables being the problem, it's that constants aren't being simplified. I found this confusing as because it certainly looks like they are being treated as floating points during evaluation. cos(pi()/2) evaluated to 6.12323e-17 rather than 0.
Yeah, I'm well aware of this. It's a subtle UX design point that's kinda tricky and I'm not sure how to get it right. The problem is that if I simplify all formulas with no dependencies to variables immediately, then simply typing 2+2 in a cell results in 4 with no way to recover the original expression input.
Basically, as it is now if the entered expression is a number, like "1" then the cell will be a variable. If it's not, but it's a valid expression formula, like "1+1", then the cell is a formula. When updating backwards only variables can be changed.
It might be better to swap the notation for constants and variables, so that 1 is a constant and #1 is a variable.
Maybe it would be less confusing to have another marker for variables? Having the same marker sometimes say «constant not variable» and sometimes «variable not constant» sounds counterintuitive
What I meant is that # would always be a variable and not-# always a constant (as opposed to now, where not-# is sometimes a variable and sometimes a constant).