PRIM | Patient Rule Induction Method for Python

The time complexity of Prim's algorithm using the adjacency matrix of a complete graph is Theta(n^2). We can see this from the pseudocode of Prim's algorithm with our adjacency matrix H:

1. Initialize a set Q of vertices not in the tree, initially all vertices. Choose the first vertex to be our root R.
2. Initialize two arrays of length n, key and parent. key will store, at position i, the minimum weight edge connecting the ith vertex to the current MST; initially, this is +infinity. parent will store, after the algorithm is done, the parent of each vertex in the MST rooted at R. Initially, parent[i] = R for all i, except the root, which has no parent.
3. Loop over the first row of H (corresponding to the root R) and assign key[i] = H[0][i]. Remove R from our set Q.
4. While Q is not empty:
   • Loop over Q, and extract any vertex u with minimum key[u]
   • For each vertex v from 0 to n-1:
     • If v in Q and H[u][v] < key[v]:
       • Set key[v] = H[u][v]
       • Set parent[v] = u

Here, the loop in (4) runs n-1 times, and inside the loop, we do Theta(n) work. In total, that gives a runtime of Theta(n^2), which is optimal for any algorithm that needs to read the entire adjacency matrix. In particular, for a generic complete graph, this is optimal, but this doesn't imply that Prim's algorithm is optimal for your specific case with a narrower class of graphs formed from distance matrices.

To show that your problem transformation is correct, we need to verify that, given a tree T with positive weights, the complete graph G(H) formed by taking the distance matrix of T as an adjacency matrix will satisfy:

1. G(H) has a unique minimum spanning tree
2. T is a minimum spanning tree of G(H).

This requires proving several properties of minimum spanning trees in general. One theorem about minimum spanning trees, proven as Corollary 3.5 in these MIT lecture notes, says that:

Let G = (V,E,w) be a connected, weighted, undirected graph. Let T be any MST and let (U, V \ U) be any cut. Then T contains a light edge for the cut.

Here, a 'light edge for a cut (U, V \ U)' means an edge whose weight is the minimum weight of all edges with exactly one endpoint in U.

Now, we just need to choose appropriate cuts to prove what we want. For an arbitrary edge e in your original tree T, consider the two trees T1 and T2 we get by deleting e.

Take the vertices of T1, which we'll call V(T1), as our cut. We need to show that in the complete graph G(H), the edge e is the unique light edge for that cut. In our original tree T, e is the only edge that crosses the cut. This means that any path with one endpoint u in V(T1) and the other endpoint v in V(T2) must include e.

Since all the weights are positive, this means that the distance in T, distance(u,v) > weight(e), for any u, v such that (u in V(T1), v in V(T2), and (u, v) != e). Since the distance in T between u and v is the weight of the edge (u, v) in our complete graph G(H), this means that e is the unique minimum weight edge that crosses the cut. Since e was an arbitrary edge in T, this now means that all edges of T must be in our MST for G(H), so the unique MST of G(H) is T.

You probably just forgot to update the reset to vid:reset-recorder, it's also from the vid extension.

vid:start-recorder doesnt take a path as input. You only need the path for vid:save-recording

In the video extensions doc at the section for vid:save-recording, they say:

Note that at present the recording will always be saved in the “mp4” format.

So you probably want so change the user message. When I tried it with the following code the file extension was written automatically.

The definition of :> is

We could use match with sort

I've tried to duplicate your problem with a fresh Debian under WSL install. I'm running Debian "bullseye" under WSL 1 under Windows 10. That Debian version must be a little newer than yours, since the GHC packages are version 8.8.4 instead of 8.4.4, but that seems to be the only difference.

Using a clean copy of that Git repository (commit 9c3b6315) with only the Makefile changed (exactly as below except with usual "tab" indentation):

Potential solution with str_extract from the stringr package.

The optimization is called "call-pattern specialization" (a.k.a. SpecConstr) this specializes functions according to which arguments they are applied to. The optimization is described in the paper "Call-pattern specialisation for Haskell programs" by Simon Peyton Jones. The current implementation in GHC is different from what is described in that paper in two highly relevant ways:

1. SpecConstr can apply to any call in the same module, not just recursive calls inside a single definition.
2. SpecConstr can apply to functions as arguments, not just constructors. However, it doesn't work for lambdas, unless they have been floated out by full laziness.

Here is the relevant part of the core that is produced without this optimization, using -fno-spec-constr, and with the -dsuppress-all -dsuppress-uniques -dno-typeable-binds flags:

I would just add a counter to count the extra days as follows:

First of all, technically when you enter the GHC.Integer.Type module you leave the realm of Haskell and enter the realm of the current implementation that GHC uses, so this question is about GHC Haskell specifically.

All the primitive operations like (<#) are implemented as a recursive loop which you have found in the GHC.Prim module. From there the documentation tells us the next place to look is the primops.txt.pp file where it is listed under the name IntLtOp.

Then the documentation mentioned earlier says there are two groups of primops: in-line and out-of-line. In-line primops are resolved during the translation from STG to Cmm (which are two internal representations that GHC uses) and can be found in the GHC.StgToCmm.Prim module. And indeed the IntLtOp case is listed there and it is transformed in-line using mainly the mo_wordSLt function which depends on the platform.

This mo_wordSLt function is defined in the GHC.Cmm.MachOp module which contains to quote:

Machine-level primops; ones which we can reasonably delegate to the native code generators to handle.

The mo_wordSLt function produces the MO_S_Lt constructor of the MachOp data type. So we can look further into a native code generator to see how that is translated into low-level instructions. There is quite a bit of choice in platforms: SPARC, AArch64, LLVM, C, PPC, and X86 (I found all these with the search function on GitLab).

X86 is the most popular platform, so I will continue there. The implementation uses a condIntReg helper function, which is defined as follows: