upvote

points

by adius3 days ago |
comments
upvoteby egl20208 hours ago|
next
[-]
There's a mystique around Mathematica's math engine. Is this groundless, or will you eventually run into problems getting correct, identical answers -- especially for answers that Mathematic derives symbolically? The capabilities and results of the computer algebra systems that I've used varied widely.
reply
upvoteby redbluered57 minutes ago|
parent|
next
[-]
Scmutils from MIT does a very good -- arguably better -- job for correctness. No symbolic integration by ideology and not identical. Sussman and Terman. Amazing attention to detailand correctness. Claude could probably bridge Scheme to Wolfram.

I'm not sure how important but- for-bug identical output really is.

reply
upvoteby adius8 hours ago|
parent|
prev|
[-]
Hard to tell honestly. So far there was always some surprisingly straight forward solution If had any problems with the math engine. There is actually a lot of public research how equations can be solved/simplified with computer algorithms. So I'm optimistic. I also stumbled upon a few cases where Mathematica itself didn't quite do things correctly itself (rounding errors, missing simplifications, etc.). So maybe it's actually a little overhyped …
reply
upvoteby Y_Y7 hours ago|
parent|
[-]
I also found problems with integrating some obscure functions a few years black, though IIRC the issue was remedies by using the amazing Rubi package:

https://rulebasedintegration.org/

reply
upvoteby cs7029 hours ago|
prev|
next
[-]
Thank you for sharing this on HN.

It's a worthwhile effort. If successful, Woxi can enable a large mass of scientists and engineers who don't have access to Mathematica to run legacy code written for it. Also, Woxi would give those scientists and engineers who regularly use Mathematica a non-proprietary, less restrictive alternative, which many of them would welcome.

How does Woxi compare to other "clean-room implementations"[a] of the same language?

--

[a] Please check with a lawyer to make sure you won't run into legal or copyright issues.

reply
upvoteby muizelaar9 hours ago|
prev|
next
[-]
How does it compare to mathics?

How close is it to being able to run rubi: https://rulebasedintegration.org/?

reply
upvoteby disentanglement9 hours ago|
parent|
[-]
You can find the whole integration routine here https://github.com/ad-si/Woxi/blob/36343ab2cbc97e5081f7c811e.... It's essentially a test mock-up (not even trying partial fraction decomposition for rational functions).
reply
upvoteby anematode5 minutes ago|
parent|
[-]

    // ∫ tan(x) dx = -ln|cos(x)| - not implemented (requires Log)
This really doesn't bode well... I'm no expert in CASes, but everything I've looked at seems very naive. Vibe coding a Mathematica replacement makes zero sense to me.
reply
upvoteby utopiah9 hours ago|
prev|
next
[-]
Interesting, thanks for sharing. Naive question as I'm not familiar with Mathematica much (but aware of it and Wolfram Alpha and related tools), how does it compare to e.g. Jupyter or Julia or maybe another language (with its framework) that might be even closer?
reply
upvoteby adius7 hours ago|
parent|
[-]
I think Wolfram Language is just so much more ergonomic. No need to import dependencies - everything's included and consistent, very readable - yet compact - syntax, less gotchas than Python, R, etc., sensible default, …
reply
upvoteby Y_Y7 hours ago|
parent|
[-]
Ymmv, but I've found that you sure do need to import things eventually, and it's not so ergonomic because most projects just end up as mega-notebooks.

Just like Python or any other language that looks easy for the learning examples, there are still hairy bits, they're just better hidden. The difference is that the debuggers for Python are far better.

Mathematica is great for quick stuff, but once you hit a particular level complexity it goes crazy. In this regard I find it similar to Bash.

reply
upvoteby apetresc9 hours ago|
prev|
next
[-]
What percentage of the overall code was written primarily by agents?
reply
upvoteby pwdisswordfishy4 hours ago|
prev|
next
[-]
LSP?
reply
upvoteby adius3 hours ago|
parent|
[-]
Not yet, but on the roadmap!
reply
upvoteby foobarqux8 hours ago|
prev|
next
[-]
How is the popularity/rank in functions.csv determined?
reply
upvoteby adius8 hours ago|
parent|
[-]
That's actually a value that Wolfram determines themselves. Here is the documentation for it: https://reference.wolfram.com/language/ref/WolframLanguageDa...

Here is e.g. all the values for the Plus[] function:

$ wolframscript -code 'WolframLanguageData["Plus", "Ranks"]' {All -> 6, StackExchange -> 8, TypicalNotebookInputs -> 5, TypicalProductionCode -> 6, WolframAlphaCodebase -> 6, WolframDemonstrations -> 4, WolframDocumentation -> 4}

reply
upvoteby dist-epoch9 hours ago|
prev|
next
[-]
Why would I use this and not Wolfram Script?

Better license? Allowed for commercial operations?

reply
upvoteby redbluered54 minutes ago|
parent|
next
[-]
License is a big deal, and not just for cost and openness, but also for practical use in pages like docker, ci/cd pipeline, cloud deployments, or other places licenses need to be dynamic.
reply
upvoteby adius8 hours ago|
parent|
prev|
[-]
Exactly! And:

- Faster startup time because of no license check

- Can run multiple instances of Woxi at the same time

- Embeddable via WASM

- Configurable via compile time flags (which features should be included)

- …

reply
upvoteby foobarqux7 hours ago|
prev|
[-]
Have you considered using quickcheck/random/property-based testing with LLM code generation to automate function implementation?
reply
upvoteby adius7 hours ago|
parent|
[-]
Yeah, I've already looked into it, but decided to keep developing it "example driven" for now. Aka I'm playing around with it, and whenever I find something that's broken I keep a note of it and then I pick those notes one by one and implement them. Once the most common things are implemented I will start writing property tests to catch all the edge cases of each feature.
reply
upvoteby foobarqux6 hours ago|
parent|
[-]
I'm saying you can go even further and automate the entire thing using LLMs/agents, it is pretty much the ideal use case: you have a black-box reference implementation to test against; descriptive documentation for what the functions should do; some explicitly supplied examples in the documentation; and the ability to automatically create an arbitrary number of tests.

So not only do you have a closed loop system that has objective/automatic pass-fail criteria you also don't even have to supply the instructions about what the function is supposed to do or the test cases!

Obviously this isn't going to be 100% reliable (especially for edge cases) but you should be able to get an enormous speed up. And in many cases you should be able to supply the edge case tests and have the LLM fix it.

(Codex is still free for the next few days if you want to try their "High"/"Extra high" thinking models)

reply
upvoteby thrtythreeforty4 hours ago|
parent|
[-]
You accidentally raise an interesting point: good, thorough public documentation, once considered a great selling point for your system, now invites automated reimplementation by competition. It would be a shame to see public docs vanish because it turns out they are literally machine readable specs.
reply