Matt's Homepage

Mathematicians are a fascinating breed. They look at problems and new fields of study for discoveries and then plug away on a single problem or set of problems for amazing amounts of time. They do this by attacking the problems from every direction using every mathematical tool they have. They use intuition and experience to find patterns, similarities to other problems, and even brute force methods. The goal is to seek out patterns, make sense of those patterns by stating conjectures, and then prove those conjectures into theorems. This often takes mathematicians years or decades – if they ever solve it at all. If nothing else, mathematicians are a persistently curious lot.

The Ramanujan Machine

With all this potential tedium, is there a way to speed some of this up? Could one automate some of the work? AI algorithms are amazing at pattern matching, so what if we use machine learning to start the ball rolling? Enter the Ramanujan Machine – after the famous Indian mathematician that saw patterns where others did not (and had no less than 2 movies made about him). This kind of software may be transformative to how mathematics is done – and some are raising questions about what it means for the field.

The concern is that the Ramanujan Machine does much more than just pattern match. The machine consists of a set of algorithms that seek out conjectures, or mathematical conclusions that are likely true but have not been proved. Researchers have already used machine learning to turn conjectures into theorems on a limited basis — a process called automated theorem proving. The goal of the Ramanujan Machine is more ambitious. It tries to identify promising conjectures in the first place.

The algorithms in the Ramanujan Machine scan large numbers of potential equations in search of patterns that might indicate the existence of formulas to express them. The programs first scan a limited number of digits, perhaps five or 10, and then record any matches and expand upon those to see if the patterns repeat further. When a promising pattern appears, the conjecture is then available for an attempt at a proof.

So far, the Ramanujan Machine has generated more than 100 intriguing conjectures so far – and several dozen have been proved. 

Epistemological questions

The question for the field is now: what does this tool mean for us.

I have already written about the problem of scientific discovery and Epistomology. Machines can now pattern match and come up with equations and descriptions that can describe physical realities, but at what point can we say that we ‘know’ something?

If a machine observes a system and spits out an answer/mathematical description, we often do not know how it arrived at that answer. Can we really say we ‘know’ a thing and are accurately describing it? Without understanding the interplay of the underlying principles that got us to that answer, it might only hold for that set of inputs.

Some would argue, that’s how we’ve always done science. Despite our best efforts, science pushes ever forward and sometimes refutes past theories. We have seen this most dramatically in medical discoveries and regularly in the fields of cosmology and quantum mechanics. However, in mathematics, this is not so. Proven theorems have held for millennium.

So where does this leave us

Honestly, I think software like the Ramanujan machine is the next logical step in mathematics and pure sciences. Just like the calculator became a tool that helped transform math 100 years ago, AI enhanced pattern matching is a next logical tool in the toolbox. Instead of relying on intuition and years of grunt work, it’s unbiased and methodical approach could help us see patterns we have missed, and do it massively faster. After all, correctly formulated mathematical proofs are proofs no matter what the source was.

While it likely cannot replace a well-trained expert, it certainly could help augment their efforts. Speeding up our rate of discoveries by orders of magnitude sounds like a very solid contribution to me.

Try out the machine here: https://www.ramanujanmachine.com/

Read more here: https://www.livescience.com/ramanujan-machine-created.html

See more here: https://www.livescience.com/ramanujan-machine-created.html?jwsource=cl

Or even download the code here: https://github.com/ShaharGottlieb/MasseyRamanujan/

Mitxela decided to make his own game console. He built the whole thing: the hardware, bios, sound, and even games (in assembly language no less). It uses an oscilloscope to generate the output.

What a guy. Read more about it here.

A recent Meetup event I went to featured Alexis Menard talking about development for foldable devices.

Ever want to see what assembly code your compiler is really generating?

There are a few reasons to want to know this. Firstly is correctness. Sometimes obscure bugs can crop up when you switch from one compiler to another, from one set of optimization settings to another, from debug to release, or even from one compiler version to another.

The second is optimization. What addressing mode(s) are being used, are there data hazards that are slowing things, are simd instructions being used? Game and high performance compute companies still spend time pulling every cycle they can out of a routine.

It used to be you had to compile and then pull the executable into a debugger and examine the code. Now, there’s an online tool that can quickly do the same. Enter the Godbolt compiler explorer.

It allows you to type in C/C++ code, select from a whole host of compilers, enter custom compiler flags, then show you the generated output.

In the case above, I wanted to verify C/C++ short-circuit comparison behavior of a variable against NULL and then dereference in the same conditional. If the compare against NULL doesn’t execute and exit before the dereference, a NULL pointer exception/segfault will result. According to C/C++ rules, there should be an early out after the comparison against NULL – and sure enough – on line 8 and 9 we see the test and exit.

Anyway – it’s a neat online tool you might give a try to learn more about the assembly your C/C++ code turns into.

Simply astounding – really looking forward to reading how they did this.

What if we flipped things on their head and had more triangles than pixels on the screen? How would that engine work…

The Microsoft team has been busy getting DirectX 12 to run in Linux – including some interesting work on containerization, GPGPU compute, and other features.

Read more about it here: https://devblogs.microsoft.com/directx/directx-heart-linux/

Electron Dust shows off a nifty machine that can bounce a ping pong ball, while keeping it balanced and centered on its moving platform. It uses combination of open-source image processing software and Arduino-controlled stepper motors to work its magic.

It is an arduino project with 120 FPS OpenCV image processing and smooth stepper motor moves. The machine calculates the ball’s 3D position from the image processing data and uses this information to control the orange ping pong ball.

Uses an e-con Systems superb See3CAM_CU135 camera. Find out more about the camera here: https://www.e-consystems.com/4k-usb-c…

This machine requires the following things to work:

• 1x Teensy 4.0 Microcontroller
• 4x StepperOnline DM442S stepper motor drivers
• 4x Nema 17 Stepper Motors with 5:1 planetary gearbox
• 1x 48V 8A power supply
• 1x e-con Systems See3CAM_CU135 camera
• 1x Windows Computer with OpenCV installed on it –

All the parts defined the Fusion360 project – Custom Windows Application (made with Unity). Read more here: https://electrondust.com/2020/03/02/t… Complete code and Fusion360 data on Github: https://github.com/T-Kuhn/HighPrecisi…

While a relatively short game, the indie horror game FAITH has gotten great accolades. It’s available for free on itch.io if you want to give it a try.

One of the more frightening elements of the game are the voices of the encountered creatures. The voices for at least one of the creepy characters was generated using a text-to-speech program called SAM (Software Automatic Mouth) written in 1982 for the Commodore 64.

The C source code is available on github, or you can give some of your own phrases a try here via a clever web interface.