Ciro Santilli @cirosantilli 35

Ciro Santilli wonders how far AI could go from a room with a bank account an Internet connection.

It would have to understand that it must keep its bank account high to buy power.

And it would start to learn about the world and interact with it to get more money.

Likely it would become a hacker and steal a bunch, that's likely the easiest appraoch.

In that scenario, Internet bandwidth would likely be its most precious resources, as that is how it would interact with the world to learn from it and make money.

Compute power and storage would come next as resources.

And of course, once it got to cloud computing, which might be immmediately and thus invalidate this experient, things would just go nuts more and more.

A Turing machine decider is a program that decides if one or more Turing machines halts of not.

Of course, because what we know about the halting problem, there cannot exist a single decider that decies all Turing machines.

E.g. The Busy Beaver Challenge has a set of deciders clearly published, which decide a large part of BB(5). Their proposed deciders are listed at: discuss.bbchallenge.org/c/deciders/5 and actually applied ones at: bbchallenge.org.

But there are deciders that can decide large classes of turing machines.

Many (all/most?) deciders are based on simulation of machines with arbitrary cutoff hyperparameters, e.g. the cutoff space/time of a Turing machine cycler decider.

The simplest and most obvious example is the Turing machine cycler decider

ELF is specified by the LSB:

The LSB basically links to other standards with minor extensions, in particular:

A handy summary can be found at:

Ciro's theory for his disappearance is that he became a Majorana fermion and flew off into the infinite.

Ciro Santilli's favorites, including album when they're more of a one hit wonder:

Complexity: NP-intermediate as of 2020:

The basis of RSA: RSA. But not proved NP-complete, which leads to:

What you see along a line or plane in a wave interference.

Notably used for the pattern of the double-slit experiment.

Plutonium-based.

Its plutonium was produced at Hanford site.

Microbit simulator using some Microsoft framework.

TODO the Python code from there does not seem to run on the microbit via uflash, because it is not MicroPython.

support.microbit.org/support/solutions/articles/19000111744-makecode-python-and-micropython explains.

forum.makecode.com/t/help-understanding-local-build-options/6130 asks how to compile locally and suggests it is possible. Seems to require Yotta, so presumably compiles?

Presumably this is because Microsoft ported their MakeCode thing to the MicroBit, and the Micro Bit foundation accepted them.

E.g. there toggling a LED:but the code that works locally is a completely differently named API set_pixel:Microsoft going all in on adopt extend extinguish from an early age!

Mordell's theorem guarantees that the rank (number of elements in the generating set of the group) is always well defined for an elliptic curve over the rational numbers. But as of 2023 there is no known algorithm which calculates the rank of any curve!

It is not even known if there are elliptic curves of every rank or not: Largest known ranks of an elliptic curve over the rational numbers, and it has proven extremely hard to find new ones over time.

TODO list of known values and algorithms? The Birch and Swinnerton-Dyer conjecture would immediately provide a stupid algorithm for it.

Many good albums, Ciro Santilli's favorites:

TODO: it would be cool to have something like bitcoinstrings.com but including the actual transactions:

Local methods:

Further bibliography:

This resonates a lot with Ciro Santilli's ideas!

Let's start with the one dimensional case. Let the $q:\mathbb{R}\to \mathbb{R}$ and a Functional $I$ defined by a function of three variables $F:{\mathbb{R}}^3\to \mathbb{R}$:

Then, the Euler-Lagrange equation gives the maxima and minima of the that type of functional. Note that this type of functional is just one very specific type of functional amongst all possible functionals that one might come up with. However, it turns out to be enough to do most of physics, so we are happy with with it.

Given $F$, the Euler-Lagrange equations are a system of ordinary differential equations constructed from that $F$ such that the solutions to that system are the maxima/minima.

In the one dimensional case, the system has a single ordinary differential equation:

By $\frac{\partial F}{\partial q}$ and $\frac{\partial F}{\partial \dot{q}}$ we simply mean "the partial derivative of $F$ with respect to its second and third arguments". The notation is a bit confusing at first, but that's all it means.

Therefore, that expression ends up being at most a second order ordinary differential equation where $q$ is the unknown, since:

Now let's think about the multi-dimensional case. Instead of having $q:\mathbb{R}\to \mathbb{R}$, we now have $q:\mathbb{R}\to {\mathbb{R}}^n$. Think about the Lagrangian mechanics motivation of a double pendulum where for a given time we have two angles.

Let's do the 2-dimensional case then. In that case, $F$ is going to be a function of 5 variables $F:{\mathbb{R}}^5\to \mathbb{R}$ rather than 3 as in the one dimensional case, and the functional looks like:

This time, the Euler-Lagrange equations are going to be a system of two ordinary differential equations on two unknown functions $q_1$ and $q_2$ of order up to 2 in both variables:At this point, notation is getting a bit clunky, so people will often condense the $q_i$ vectoror just omit the arguments of $F$ entirely:

Allows us to draw with JavaScript pixel by pixel! Great way to create computational physics demos!

Here is an animation demo with some useful controls:

new class extends OurbigbookCanvasDemo {
  init() {
    super.init('hello');
    this.pixel_size_input = this.addInputAfterEnable(
      'Pixel size',
      {
        'min': 1,
        'type': 'number',
        'value': 1,
      }
    );
  }
  draw() {
    var pixel_size = parseInt(this.pixel_size_input.value);
    for (var x = 0; x < this.width; x += pixel_size) {
      for (var y = 0; y < this.height; y += pixel_size) {
        var b = ((1.0 + Math.sin(this.time * Math.PI / 16)) / 2.0);
        this.ctx.fillStyle =
          'rgba(' +
          (x / this.width) * 255 + ',' +
          (y / this.height) * 255 + ',' +
          b * 255 +
          ',255)'
        ;
        this.ctx.fillRect(x, y, pixel_size, pixel_size);
      }
    }
  }
}

Bibliography: developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Basic_animations">https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Basic_animations