dnf | Replaces YUM

Check out this article: CentOS Linux EOL

The below commands helped me:

First, it's good to note the difference between equivalence and equisatisfiability. In general, converting an arbitrary boolean formula (say, something in DNF) to CNF can result in a exponential blow-up in size.

This blow-up is the issue with your from_dnf approach: whenever you handle another product term, each of the literals in that product demands a new copy of the current cnf clause set (to which it will add itself in every clause). If you have n product terms of size k, the growth is O(k^n).

In your case n is actually a function of k!. What's kept as a product term is filtered to those satisfying the view constraint, but overall the runtime of your program is roughly in the region of O(k^f(k!)). Even if f grows logarithmically, this is still O(k^(k lg k)) and not quite ideal!

Because you're asking "is this satisfiable?", you don't need an equivalent formula but merely an equisatisfiable one. This is some new formula that is satisfiable if and only if the original is, but which might not be satisfied by the same assignments.

For example, (a ∨ b) and (a ∨ c) ∧ (¬b) are each obviously satisfiable, so they are equisatisfiable. But setting b true satisfies the first and falsifies the second, so they are not equivalent. Furthermore the first doesn't even have c as a variable, again making it not equivalent to the second.

This relaxation is enough to replace this exponential blow-up with a linear-sized translation instead.

The critical idea is the use of extension variables. These are fresh variables (i.e., not already present in the formula) that allow us to abbreviate expressions, so we don't end up making multiple copies of them in the translation. Since the new variable is not present in the original, we'll no longer have an equivalent formula; but because the variable will be true if and only if the expression is, it will be equisatisfiable.

If we wanted to use x as an abbreviation of y, we'd state x ≡ y. This is the same as x → y and y → x, which is the same as (¬x ∨ y) ∧ (¬y ∨ x), which is already in CNF.

Consider the abbreviation for a product term: x ≡ (a ∧ b). This is x → (a ∧ b) and (a ∧ b) → x, which works out to be three clauses: (¬x ∨ a) ∧ (¬x ∨ b) ∧ (¬a ∨ ¬b ∨ x). In general, abbreviating a product term of k literals with x will produce k binary clauses expressing that x implies each of them, and one (k+1)-clause expressing that all together they imply x. This is linear in k.

To really see why this helps, try converting (a ∧ b ∧ c) ∨ (d ∧ e ∧ f) ∨ (g ∧ h ∧ i) to an equivalent CNF with and without an extension variable for the first product term. Of course, we won't just stop with one term: if we abbreviate each term then the result is precisely a single CNF clause: (x ∨ y ∨ z) where these each abbreviate a single product term. This is a lot smaller!

This approach can be used to turn any circuit into an equisatisfiable formula, linear in size and in CNF. This is called a Tseitin transformation. Your DNF formula is simply a circuit composed of a bunch of arbitrary fan-in AND gates, all feeding into a single arbitrary fan-in OR gate.

Best of all, although this formula is not equivalent due to additional variables, we can recover an assignment for the original formula by simply dropping the extension variables. It is sort of a 'best case' equisatisfiable formula, being a strict superset of the original.

To patch this into your code, I added:

As suggested in the comments, it is important to download the exact rpm package that dnf is configured to use. This can be found by rpm -qa python3.

After finding and downloading this package, install it using the rpm -i command. A successful installation will create the /usr/bin/python_version folder. For me, it was python3.10, so /usr/bin/python3.10.

When this is done, remove the existing symlink at /usr/bin/python3, and instead link to the newly created python version.

If you see errors about a specific library missing, you can use dnf itself to find out the name. For example, on Fedora 35:

solved by adding --allowerasing

If the image already exists in the local docker engine, docker will not pull it again unless requested. There are flags to request the image gets pulled again on some commands. Otherwise, if you see the image change, I would look for either a docker pull command being run, or the images getting cleaned (e.g. with a prune command).

It was selinux, I solved it by disabling selinux.

The upgrade came with kernel 5.16:

https://www.phoronix.com/scan.php?page=news_item&px=SELinux-IO_uring-Linux-5.16

Seems like these 2 documentation links are a lie:

• https://docs.okd.io/4.9/installing/installing_sno/install-sno-preparing-to-install-sno.html
• https://docs.okd.io/4.9/installing/installing_sno/install-sno-installing-sno.html

According to these 2 issues:

• https://github.com/openshift/okd/discussions/1012
• https://github.com/openshift/openshift-docs/issues/39759

OKD does not support "installation with Assisted Installer" and these links are "installation with Assisted Installer". Nice waste of time.

Finally I found the solution:

Since both system has the arch and OS. I cross copied the R compiled installations between them. The R which was compiled on the problematic system, but was run on the correct one gave the warnings below after the calling of the install.packages("renv", repos="https://cran.wu.ac.at/")