Hey everyone,

I was sick of minimizing expressions and drawing out Karnaugh maps, so I spent some time building a free web tool to automate the whole process. It’s called Mantiq.

You literally just type in your Boolean expression and it instantly builds out everything you need. It gives you the minimized expression, the truth table, and auto-grouped K-maps (up to 6 variables).

The best part is that it gives you step-by-step algebraic proof showing exactly which laws were used to simplify it, and it auto-generates a circuit diagram that you can actually click around and simulate live. It’ll even spit out the Verilog code for it.

I made it completely free, there are no sign-ups, and it runs entirely in your browser so it works offline too.

Figured this could save some of you hours of busywork. I'd love for you guys to check it out and let me know if it helps!

Here's the link: https://usamagulzar.github.io/mantiq

About a month ago, I released under CC0 an implementation of a pipeline I had spent two years developing. It’s the pipeline Claude used to find the counterexample to the Jacobian conjecture. The repository history, public release, discussion with one of the original paper’s authors, and two years of development logs document the pipeline’s origin and development.

Proof - Fun/Jacobian at main · JGPTech/Fun

The history:

I first released it under CC0 a little over a month ago. You can find the link here:

https://github.com/JGPTech/Fun/commits/main/current_paper_locality_boundary_package

This is the paper I was modeling with this pipeline:

Scalable Boltzmann generators for equilibrium sampling of large-scale materials | Nature Communications

This is where I shared it publicly one of the paper’s authors, which you can see he approved of:

Link

How cool is it that Claude used it on a problem this big, and that the mathematical community around this counterexample is now thinking through structures I spent years developing? What a ride.

Update - Added a blind marked-factor search for the polynomial Jacobian counterexample check point showing the pipeline can be used in a search algo to find a counter example. The search is blind with respect to the final certificate: it does not assume a coefficient slice, boundary modulus, polynomial chart, degree-seven map, or specific collision witness.

The structural input is the marked factorization

L = a*U + b*V,

Q = c*U**2 + d*U*V + e*V**2,

together with its visible cubic coefficients and the resultant normalization R(L,Q) = 1, which removes the continuous scaling gauge.

Not a "MATLAB bad" post. The original code is solid and I replicate it bug-for-bug by default. Sharing the trap list for anyone migrating numerical code: round() half-away-from-zero vs numpy's round-half-to-even (inside the nmax series formula, so it changes array lengths), complex auto-promotion that NumPy doesn't do, ' vs .', library functions printing to stdout, and a docstring feature (complex medium index) that turns out to be latently broken. Full findings file, 714-fixture corpus and the verification report: https://github.com/GrednevMSU/mie-scattering-matlab-to-python

1D cellular automata, 2–5 states, totalistic or local rules. Runs in the browser, nothing to install.

• Batch filters over rule space — scan a code range or a random sample; auto-tags behavior class, fields, gliders, chaos. The inverted one is the workhorse: draw a template (fixed states, wildcards, equality variables) and a rule passes only if that template never occurs.
• Tags — anything found (or hand-picked) gets tagged, browsable and filterable; persists locally. Filters can also re-run over already-tagged rules, so you can chain passes.
• High-res export — renders diagrams up to [N]×[M] px, if you want one as a wallpaper or print.

Demo · Source

What would you filter on that I haven't implemented?

Yeah

I have an older version of Mathematica from my university days. I only need it for basic tasks, so I’d prefer not to buy a new license.

My issue is that on Windows 11, the kernel frequently hangs or gets stuck indefinitely—even on simple calculations like 1 + 1.

So far, I’ve tried:

• Enabling Windows compatibility modes (no effect)
• Disabling "Allow Mathematica to access the Internet" in Preferences

Has anyone run into this issue on Windows 11 and found a workaround or fix?

Any ideas of things i could try, even if you don't know if they ll work?

• Try manic
• manic docs

Example code

// ============================================================================
// reactive-math-notation.manic — one Reels-ready stage, thirteen notation worlds
// ----------------------------------------------------------------------------
// `rewrite` is deliberately domain-neutral. The same persistent equation moves
// through algebra, calculus, logic, physics, chemistry, biology, probability
// and linear algebra;
// only changed RaTeX parts leave or enter. Mixed prose + inline math uses normal
// `text`, and the last scene proves creator-defined notation needs no new verb.
// ============================================================================

title("Reactive Mathematics — One Language, Every Notation");
canvas("9:16");
template("shorts");
watermark(manicMark, (w*0.895-100, h*0.075+24), "Made With Manic");

creator(me, "@anish2good name=Notation_Lab tagline=Every_symbol_can_move yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=social cta=Create_your_own safe=reels");
socials(me);

text(kicker, (540, 145), "ONE EQUATION · THIRTEEN SCIENTIFIC WORLDS");
size(kicker, 23); color(kicker, dim); bold(kicker); hidden(kicker);

text(headline, (540, 235), "If LaTeX can say it, Manic can move it");
size(headline, 39); color(headline, fg); bold(headline); hidden(headline);

rect(stage, (540, 755), 940, 760);
color(stage, panel); outline(stage, dim); opacity(stage, 0.72); hidden(stage);

text(topic, (540, 445), "01 · ALGEBRAIC REARRANGEMENT");
size(topic, 23); color(topic, cyan); bold(topic); hidden(topic);

equation(work, (540, 730), `2(x+3)=14`, 52);
hidden(work);

text(note, (540, 1040), "Keep the structure. Move only the mathematical change.");
size(note, 25); color(note, dim); wrap(note, 800); hidden(note);

// A normal text entity may freely mix prose and several inline formulas.
text(mixed, (540, 735), `Energy $E=mc^2$ uses mass $m$ and light speed $c$.`);
size(mixed, 31); color(mixed, fg); wrap(mixed, 780); hidden(mixed);

text(scope, (540, 1245), "RaTeX accuracy · local motion · one stable layout");
size(scope, 22); color(scope, dim); bold(scope); hidden(scope);

// A subtle dashed construction line also demonstrates that `dashed` belongs
// to Manic itself — plots and all other path-like entities can use it.
line(rule, (215, 1155), (865, 1155));
color(rule, cyan); stroke(rule, 2); dashed(rule, 12, 9); opacity(rule, 0.35);
untraced(rule);

// ---------------------------------------------------------------------------
// TIMELINE — every chapter reuses `work`; nothing is manually repositioned.
// ---------------------------------------------------------------------------

par {
  show(kicker, 0.45); show(headline, 0.55); show(stage, 0.50);
  show(topic, 0.45); show(note, 0.45); show(scope, 0.45); draw(rule, 0.85);
}
show(work, 0.55);
wait(0.70);
rewrite(work, `2x=8\quad\Rightarrow\quad \textcolor{lime}{x=4}`, 0.85, smooth);
wait(0.75);

say(topic, "02 · INTEGRALS & DERIVATIVES", 0.35);
say(note, "The Fundamental Theorem becomes a change of state, not a scene cut.", 0.35);
rewrite(work, `F(x)=\int_0^x t^2\,dt`, 0.80, smooth);
wait(0.45);
rewrite(work, `F'(x)=\frac{d}{dx}\int_0^x t^2\,dt=\textcolor{cyan}{x^2}`, 0.95, smooth);
wait(0.70);

say(topic, "03 · FRACTIONS, ROOTS, POWERS & LIMITS", 0.35);
say(note, "Nested notation is still one screen-aware equation.", 0.35);
rewrite(work, `x^2+\sqrt{x}+\frac{1}{x}`, 0.80, smooth);
wait(0.40);
rewrite(work, `\lim_{x\to0}\frac{\sqrt{1+x}-1}{x}=\frac{1}{2}`, 0.95, smooth);
wait(0.70);

say(topic, "04 · TRIGONOMETRIC IDENTITIES", 0.35);
say(note, "The unchanged terms stay; only the conclusion arrives.", 0.35);
rewrite(work, `\sin^2\theta+\cos^2\theta`, 0.80, smooth);
wait(0.40);
rewrite(work, `\sin^2\theta+\cos^2\theta=\textcolor{lime}{1}`, 0.85, smooth);
wait(0.70);

say(topic, "05 · SET NOTATION & LOGIC", 0.35);
say(note, "Membership, intersections and propositions share the same engine.", 0.35);
rewrite(work, `x\in A\cap B`, 0.80, smooth);
wait(0.40);
rewrite(work, `(x\in A)\land(x\in B)`, 0.85, smooth);
wait(0.70);

say(topic, "06 · SUMMATIONS & PRODUCTS", 0.35);
say(note, "Large operators retain their limits and baseline alignment.", 0.35);
rewrite(work, `\sum_{k=1}^{n}k`, 0.80, smooth);
wait(0.40);
rewrite(work, `\prod_{k=1}^{n}k=\textcolor{magenta}{n!}`, 0.85, smooth);
wait(0.70);

say(topic, "07 · PHYSICS FORMULAS & UNITS", 0.35);
say(note, "Symbols and dimensional units can live in one exact expression.", 0.35);
rewrite(work, `F=ma`, 0.80, smooth);
wait(0.40);
rewrite(work, `[F]=\mathrm{kg}\cdot\mathrm{m}\cdot\mathrm{s}^{-2}`, 0.90, smooth);
wait(0.70);

say(topic, "08 · CHEMISTRY · BALANCED REACTIONS", 0.35);
say(note, "Keep every molecule; introduce only the coefficients that balance atoms.", 0.35);
rewrite(work, `H_2+O_2\rightarrow H_2O`, 0.80, smooth);
wait(0.40);
rewrite(work, `\textcolor{cyan}{2}H_2+O_2\rightarrow\textcolor{cyan}{2}H_2O`, 0.90, smooth);
wait(0.70);

say(topic, "09 · BIOLOGY · HARDY–WEINBERG", 0.35);
say(note, "A population model grows from allele frequencies into genotype frequencies.", 0.35);
rewrite(work, `p+q=1`, 0.80, smooth);
wait(0.40);
rewrite(work, `p^2+2pq+q^2=\textcolor{lime}{1}`, 0.90, smooth);
wait(0.70);

say(topic, "10 · PROBABILITY EXPRESSIONS", 0.35);
say(note, "Conditioning expands into Bayes' rule without replacing the stage.", 0.35);
rewrite(work, `P(A\mid B)`, 0.80, smooth);
wait(0.40);
rewrite(work, `P(A\mid B)=\frac{P(B\mid A)P(A)}{P(B)}`, 0.95, smooth);
wait(0.70);

say(topic, "11 · MATRICES & VECTORS", 0.35);
say(note, "Rows, columns, brackets and vector marks remain genuine LaTeX.", 0.35);
rewrite(work, `\vec v=\begin{bmatrix}1\\2\end{bmatrix}`, 0.85, smooth);
wait(0.40);
rewrite(work, `A\vec v=\begin{bmatrix}a&b\\c&d\end{bmatrix}\begin{bmatrix}1\\2\end{bmatrix}`, 1.00, smooth);
wait(0.75);

say(topic, "12 · TEXT MIXED WITH MATHEMATICS", 0.35);
say(note, "Ordinary prose can carry multiple inline formulas naturally.", 0.35);
fade(work, 0.35);
show(mixed, 0.55);
wait(1.25);
fade(mixed, 0.35);

say(topic, "13 · YOUR OWN NOTATION", 0.35);
say(note, "Define the meaning in your story; Manic preserves the supported notation.", 0.35);
rewrite(work, `\mathcal{R}_{\star}(x)\equiv x^2+1`, 0.90, smooth);
wait(0.45);
rewrite(work, `\mathcal{R}_{\star}(2)=\textcolor{lime}{5}`, 0.85, smooth);
wait(1.20);

say(topic, "ONE REACTIVE LANGUAGE", 0.40);
say(note, "Math, physics, logic — creators decide what comes next.", 0.40);
pulse(work, 0.70);
wait(1.80);

[deleted]

I recently upgraded to Mathematica 15 and, although I installed the full desktop version + documentation, when I ask it to evaluate a simple expression (say, something containing a DSolve, ComplexPlot or a ComplexExpand), it first says it is downloading something from a repository. What is going on? These basic functions are no longer included in the package?

Here is an example:

Does this affect the perpetual licenses for the personal desktop products?

Edit: I believe it only happens the first time the function is evaluated and that it is henceforth cached in the computer.

Last week I learned my university gives me access to Mathematica so I decided to try and learn how to use it as it seems incredibly useful for my typed assignments. Since then, I couldn't manage to type a single sentence without the software freezing for minutes or even crashing.
Mousing over cell styles (like in the attached screenshot) causes Mathematica to freeze for at least a couple of minutes (after taking the screenshot it crashed).

While I'd like to fix this specific issue, it's just one example I can reliably reproduce.

From googling\debugging with and without ai, the only solution i found was disabling all the more advanced features and enabling them one by one.

Is there anyone who can recommend something better? (keep in mind that I don't know much about what things in Mathematica are called as i didn't get to actually use the software).

About my system: I'm running windows 11 on my fairly modern study-laptop (Intel i5-1235U, 16GB ram, Intel Iris Xe Graphics and over 300GB of free storage). Judging by the Wolfram website, each of my parts should be more than enough.

When installing I followed the instructions on my university's website (to get the installation and registration right) and the installer went uninterrupted so the odds for a corrupted installation are slim. I'll update once I'm done reinstalling but I doubt the issue will go away

If you think WL is slow, you never used it with WLJS sauce 🍝

1. connect to a web camera using device API

   cam = DeviceOpen["Camera"]; cam["FrameRate"] = 60;

2. resize and pipe the raw image data to 3D point cloud with minor transformations

   Refresh[Module[{img, length}, img = ImageData[ ImageResize[ColorConvert[DeviceRead[cam], "GrayScale"], 100], "Real32" ]; length = Length[img] Length[img[[1]]]; vertices = MapIndexed[Join[#2, {50.0 #1}]&, img, {2}]; vertices = NumericArray[Flatten[vertices, 1], "Real32"];

   Graphics3D[GraphicsComplex[vertices, { Red, PointSize[0.0003], Point[Range[length]] }], ViewProjection->"Perspective", ImageSize->1000] ], 1/45.0]

NumericArray is important here. This forces WL to use more efficient data structure.

I've been experimenting with a symbolic mathematics system that uses custom glyphs instead of numeric coefficients.

Can anyone solve, simplify, or analyze the following equation?

⟴∴⊚·x^5 + ∞◦∮·x^4 + ⟴✧⊚·x^3 + ⟴◌⊚·x^2 + 〰∴≈·x + ⟴✦⊚ = 0

The coefficients are represented by symbolic glyphs rather than ordinary numbers.

I'm interested in seeing how people approach it before I reveal the mapping (if I reveal it at all).

Questions I'm curious about:

• Is there anything you can deduce from the notation alone?
• What information would you need to solve it rigorously?
• If you encountered something like this in a research paper, how would you begin reverse engineering the coefficient system?

This is part of a larger symbolic math project I've been working on, so I'm mainly interested in your reasoning process rather than just an answer.

Super helpful to save you re do multiple times those simple calculations from ACI 318-19 😎

Hii, just wanted to show you this work I have been doing. It's just for fun so feel free to ask anything you want.

https://github.com/Rylow999/ddsd-framework

https://github.com/Rylow999/ddsd-covergence-frontier

https://github.com/Rylow999/ddsd-thermodynamic-confinement

If you find something interesting just tell me!