[1-basis C] [2-basis C-O] Question about the ideal minimization process #13

GinoGiotto · 2026-05-19T21:22:25Z

GinoGiotto
May 19, 2026

I chose the "General" category because I figured that this post contains a bit more than just a question: it contains some thoughts, results and a feature suggestion as well.

I've recently been exploring in the proof system derived from impsingle, which is a single axiom for implicational calculus. It has as many symbols as ax-2, but with the strength of { ax-1, ax-2, peirce }, therefore it can derive every tautology that contains the implication symbol only. A peculiarity of impsingle is that it is apparently not only the shortest axiom for implicational calculus, but it is also supposed to be the unique shortest axiom, so it captured my attention.

So far, I've derived a few theorems:

% impsingle
CCCpqrCCrpCsp = 1

% id
[0] Cpp = DDDDD1D1111DDD1D11111

% ax-1
[1] CpCqp = DDD11DDD1D11111

% imim1
[2] CCpqCCqrCpr = DDDD1D1D1DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D1111111DDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDD1DDDD1D1D1D1DDDD1D1D1DDD1D1111111111D1DDD1D1DDD1D111111111DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDD1DDDD1D1D1D1DDDD1D1D1DDD1D1111111111D1DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D111111111DDDD1D1D1DDD1D1111111

% peirce
[3] CCCpqpp = DDD1DDD1D1DDD1D111111DDD1D11111

% ax-2
[4] CCpCqrCCpqCpr = DDDD1D1D1DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D1111111DDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D111111111DDD1DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D11111111D1DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D1111111DDDD1D1D1DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D1111111DDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDD1DDDD1D1D1D1DDDD1D1D1DDD1D1111111111D1DDD1D1DDD1D111111111DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDD1DDDD1D1D1D1DDDD1D1D1DDD1D1111111111D1DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D111111111DDDD1D1D1DDD1D11111111

I started with a proof of ax-2 with roughly 40.000 steps and managed to compressed it to 573 with fairly little effort. The question is what would be the ideal procedure to compress it further. So far I’ve just been lazily using --transform [-z] [-x <limit>] with few minutes of computing time and it was good enough, but I’m sure there are more systematic methods for this kind of exploration.

To make the system complete for classical propositional calculus, it is sufficient to add the principle of explosion falim |- ( F. -> ph ), which is also the unique shortest possible second axiom we could add. So overall, this pair of axioms form an elegant axiomatization of classical propositional calculus.

Unfortunately pmGenerator does not support the falsum constant, so I'm not sure how to show the derivation of ax-3 using the D-notation. However, I proved ax-3 in this MM1 database. I named impsingle ax_imp, since effectively, it describes implication. The mm0-rs LSP server shows no errors on VS Code so the proofs should be correct (I also verified it with mm0-c paired with the corresponding MM0 file). Lately, I’ve found that MM1 is more convenient to use than MM, because it can handle these "long and ugly" proofs without a perceptible slowdown. The proofs are also more easily readable than MM and they can be converted into condensed detachment with a simple script.

It would be nice if pmGenerator supported the falsum constant, even Meredith's single axiom becomes shorter if we use C-O calculus:

|- ( ( ( ( ph -> ps ) -> ( ch -> F. ) ) -> th ) -> ta ) -> ( ( ta -> ph ) -> ( ch -> ph ) )

This version has 19 symbols instead of the 21 of the traditional Meredith's axiom, so maybe the set of connectives { -> , ⊥ } is more natural than the set { -> , ¬ } for propositional logic. I wonder if this choice of terms would allow a slight speed-up in computation or parsing.

Soapbox thoughts

It is known that Meredith's axiom and Walsh's six axioms are the shortest possible single axioms for classical propositional calculus. However, I would argue that the shorter ax_imp already does most of the job on its own, despite containing only the implication connective.

Here is the reason I think so, starting with an example:

Let's take a tautology that has the negation connective, say ax-3:

|- ( ( ~p -> ~q ) -> ( q -> p ) )

We can write it in terms of F. and -> like so:

|- ( ( ( p -> F. ) -> ( q -> F. ) ) -> ( q -> p ) )

How do we prove it using ax_imp and ax_fal? Well, there is a trick, we can replace all occurrences of F. with a new variable, say r, and add an antecedent that says that such new vairiable r implies the conclusion (in this case p). Such procedure generates the expression:

|- ( ( r -> p ) -> ( ( ( p -> r ) -> ( q -> r ) ) -> ( q -> p ) ) )

This new statement has two properties: it is still a tautology and it is expressed exclusively using the implication connective, therefore it is provable using only ax_imp (see the MM1 file for the proof).

To derive ax-3, it's sufficient to discharge the newly added antecedent with ax_mp and ax_fal, that's it. This shows that the computational heavy lifting is effectively performed by ax_imp. The principle of explosion ax_fal is such a vestigial axiom that can be used just once at the end of the proof. My conjecture is that the same method can be applied to every theorem that needs ax_fal, that is, for every theorem that requires the principle of explosion, it exists a proof that uses ax_fal just once at the end of the proof, like in the example of ax-3 (although this method probably doesn't provide the minimal proof).

Another example with a longer formula:

|- ( ~( ~p -> ~~q ) -> ( ( ~p -> ( ~r -> q ) ) -> r ) )

Expressed in the { -> , ⊥ } basis, it becomes:

|- ( ( ( ( p -> F. ) -> ( ( q -> F. ) -> F. ) ) -> F. ) -> ( ( ( p -> F. ) -> ( ( r -> F. ) -> q ) ) -> r ) )

Now we apply the method. We replace the constant F. with a new variable s and we add an antecedent that says that such new variable s implies the conclusion r:

|- ( ( s -> r ) -> ( ( ( ( p -> s ) -> ( ( q -> s ) -> s ) ) -> s ) -> ( ( ( p -> s ) -> ( ( r -> s ) -> q ) ) -> r ) ) )

Once more, we obtained a tautology of implicational calculus, therefore provable with ax_imp. To derive the original, it suffices to write D[0]2 as D-proof, where D is modus ponens, [0] is the above lemma and 2 is ax_fal.

But there is more. The axiom ax_imp is more powerful that intuition might suggest. Consider this tautology:

 |- ( ( ~~p -> p ) /\ ( ( ~q -> ~r ) -> ( r -> q ) ) )

It is a conjunction of notnotr and ax-3, and it has the negation symbol, therefore its proof should require both ax_imp and ax_fal, right? No, ax_imp suffices to prove it.

We first unwrap the defined symbols /\ and ~ , which can be done natively in MM1 (I'm actually not sure if this works in MM):

|- ( ( ( ( ( p -> F. ) -> F. ) -> p ) -> ( ( ( ( q -> F. ) -> ( r -> F. ) ) -> ( r -> q ) ) -> F. ) ) -> F. )

We observe that the generated statement is an instance of a theorem of implicational calculus. Therefore we can simply choose a generalization by replacing F. with a new variable (we don't need to add an antecedent here):

|- ( ( ( ( ( p -> s ) -> s ) -> p ) -> ( ( ( ( q -> s ) -> ( r -> s ) ) -> ( r -> q ) ) -> s ) ) -> s )

Since the last statement is provable using ax_imp only, the original conjunction is provable from it as well, without the need of using ax_fal.

I think this system is quite neat, and it may suggest that Meredith’s axiom and Walsh’s axioms are a bit "overkill". At the end of the day, impsingle suffices to derive the structural complexity of propositional logic, and it looks even more special if we consider that it is apparently unique in its minimal length.

xamidi · 2026-05-20T17:00:32Z

xamidi
May 20, 2026
Maintainer

Unfortunately pmGenerator does not support the falsum constant [...]

This is false. Quoting from pmGenerator's readme:

At this point, they can use only up to two nullary (O,V), five unary (L,M,N,P,Z), and twelve binary (A,B,C,D,E,F,G,J,K,S,U,X) connectives [...]

O is the standard symbol for falsum. My logic-structuralizer tool translates it to ⊥ accordingly; it has an example “ψ” to effortlessly display standard translations for all supported symbols. The following (unpublished) definition is where I originally took my operators from:

_^image

However, as also noted in the readme, standard notation is mostly irrelevant for our syntactic approach. More precisely, the meaning of symbols that are not used in any inference rules is defined solely by axioms, thus only arity matters for them. For example, one could very well swap O with V and pmGenerator would generate the same proofs of equivalent theorems in non-standard notation (where V means falsum, despite being standard notation for verum).

This entails that many non-standard systems can be defined in pmGenerator, even those which include weird stuff like custom modal operators. Proof systems are supported as long as there are available symbols of corresponding arity for its operators, and as long as no additional rules of inference are required.

One can also introduce additional symbols using more axioms — the kind of axioms that are called definitions in Metamath. [example]
A "purity mode" to distinguish between using aliases vs. definitions is explained in nd/NdConverter.h. The long comment also provides a bunch of theorems that are sufficient (and internally used) to import natural deduction proofs of classical propositional logic into Hilbert systems. Theorems 16–19 make use of falsum.

This version has 19 symbols instead of the 21 of the traditional Meredith's axiom, so maybe the set of connectives { -> , ⊥ } is more natural than the set { -> , ¬ } for propositional logic.

I don't think that fewer ingredients necessarily make something “more natural”, or similar. I consider C-N calculus more pure than C-O calculus since negations are straightforward and natural (we say “not” very often), whereas defining Np as CpO relies on the principle of explosion, which is neither trivial nor universal, and it bloats up very simple statements.

I would argue that the shorter ax_imp already does most of the job on its own, despite containing only the implication connective.

It provides structure based on which modus ponens with substitution can do most of the job, at least.

I think this system is quite neat, and it may suggest that Meredith’s axiom and Walsh’s axioms are a bit "overkill". At the end of the day, impsingle suffices to derive the structural complexity of propositional logic, and it looks even more special if we consider that it is apparently unique in its minimal length.

I suppose you consider the 21-symbol C-N single axioms “overkill” since there are only 16 symbols in CCCpqrCCrpCsp,COp, but this is only one of many qualities.

I agree that this 2-basis is neat and special in its own way. However, to minimize components, we can use D calculus or X calculus (NAND or NOR), each of which comes with a weird rule of inference and abominations as formulas. To minimize proof steps in general, we can use large sets of axioms, despite knowing very little as to how. But we don't even know what to use in order to minimize proof steps for 1-bases (or 2-bases, 3-bases, etc.). We need much more research to answer this, and it will also shed light on the previously mentioned “how”.

Questions regarding complexity can only be answered when the systems in question are sufficiently explored, which is no easy task. In regard to complexity, all 1-bases are overkill, and certainly more so than some 2-bases, which are certainly more overkill than some 3-bases, and so on. Good points could also be made that all Hilbert systems are overkill in many ways. But they can still allow us to explore fundamental syntactic relationships.

By the way, I chose minimal C-N bases to demonstrate pmGenerator's capabilities because comparing them with each other highlights how vastly intricate Hilbert systems are and how differently they behave, even when they appear similar at first glance.

I started with a proof of ax-2 with roughly 40.000 steps and managed to compressed it to 573 with fairly little effort. The question is what would be the ideal procedure to compress it further. So far I’ve just been lazily using --transform [-z] [-x <limit>] with few minutes of computing time and it was good enough, but I’m sure there are more systematic methods for this kind of exploration.

Hilbert systems tend to emerge syntactically in ways that are far from trivial. So I doubt there is a general procedure to find near-minimal D-proofs that doesn't require lots of computing resources. Core features of pmGenerator are precisely to find non-trivial shortcuts using extensive computations.

When looking for small proofs, I wouldn't bother to import and compress long proofs like those found in Metamath's .mm databases. Unless I really struggle to prove a theorem at all, in which case the imported proof should still be compressed based on data generated by pmGenerator!

In summary, one should not expect great results by merely using proof compression on low-quality data.
However, there are many possible (highly data-sensitive) trade-offs.

So far, I've derived a few theorems [...]

For example, your proof of L1:CCpqCCqrCpr [i.e. imim1:(p→q)→((q→r)→(p→r))] has 323 steps. Here is how I found a 119-step proof without even running proof compression.

I played with impsingle on my (slow and old) laptop last year for a few days. According to my notes, I used

./pmGenerator -c -n -s CCCpqrCCrpCsp -g -1

to exhaustively generate up to dProofs65.txt, then

./pmGenerator -c -n -s CCCpqrCCrpCsp --extract -l 50 -d

which extracted 205386 proofs of theorems with up to 50 symbols (out of 685742 proofs).
Based on those, I used -g with -l 50 to generate up to dProofs77.txt, e.g.

./pmGenerator -c -n -s CCCpqrCCrpCsp -e 1 -g 77 -l 50

assuming that the previous extraction was stored in subfolder extraction-1. Then I created a new extraction like

./pmGenerator -c -n -s CCCpqrCCrpCsp -e 1 --extract -l 30
Replaced dProofs3.txt, …, dProofs33.txt with exhaustive proof files.
Replaced dProofs35.txt, …, dProofs37.txt with -l 50 proof files.
Replaced dProofs59.txt, …, dProofs77.txt with -l 25 proof files (copied from yet another extraction).

Finally, I used -g with -l 30 on this extraction to find a proof of L1:CCpqCCqrCpr in dProofs119.txt:

DDDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111D1DDD11DDD1D111111111DDDD1D1D1DDD1D1111111:CC0.1CC1.2C0.2

(I didn't mean to reproduce this, so I may have missed some details of my approach.)

The example is very sensitive on data: It requires theorems of certain lengths with certain proof lengths to not be filtered out. In contrast, proof compression depends highly on which theorems are included. Those which are merely included because they are useful in theory (which is what Metamath's databases mainly consist of) are unlikely very useful when it comes to short syntactic derivations. In my experience, (partial) exhaustive search is pretty effective to find good candidates to build upon.

Back then, I did not find a short proof of A2:CCpCqrCCpqCpr [i.e. ax-2:(p→(q→r))→((p→q)→(p→r))].

However, since you asked, I now started computing jobs to explore both CCCpqrCCrpCsp and CCCpqrCCrpCsp,COp at my university's computing cluster. I will report back interesting findings!

Please tell me if you run into further troubles.

1 reply

xamidi May 26, 2026
Maintainer

Update

Next up are srun -n 60 ./pmGenerator -c -n -s CCCpqrCCrpCsp -m 83 and srun -n 60 ./pmGenerator -c -n -s CCCpqrCCrpCsp,COp -m 81 [each running on 60 CLAIX-2023 computing nodes, each with 2x Intel Xeon 8468 Sapphire (2.1 GHz, 96 cores)] to generate dProofs83.txt from dProofs83-unfiltered83+.txt for CCCpqrCCrpCsp, and dProofs81.txt from dProofs81-unfiltered81+.txt for CCCpqrCCrpCsp,COp.

Unfortunately, the cluster is currently a bit overused, so the scheduled multi-node jobs take a few extra days until they start, but once they're running, they only take several hours to complete. The plan is to generate up to dProofs83.txt for both systems, then use -g -u on single nodes with 2 TiB memory until memory exhaustion, and then proceed depending on results.

Here are some current search results.

_{^{CCCpqrCCrpCsp}}

$ ./pmGenerator -c -n -s CCCpqrCCrpCsp --search Cpp,CpCqp,CCpqCCqrCpr,CCCpqpp,CCpCqrCCpqCpr -n -s -d
[...]
989.56 ms taken to load and search 3499861 lines from 'dProofs81.txt'. [tid:22558225184320]
13403.77 ms (13 s 403.76 ms) taken to load and search 47493930 lines from 'dProofs83-unfiltered83+.txt'. [tid:22558340503104]
Search completed after 13407.93 ms (13 s 407.93 ms).
Found 3 of 5 formula schemas. Minimal results:
Found [0] : "C0.0" (originally "Cpp")
	in line 93 - DDDDD1D1111DDD1D11111:C0.0
	of 'dProofs21.txt'.
	Substitution is {(0,0)}.
Found [1] : "C0C1.0" (originally "CpCqp")
	in line 29 - DDD11DDD1D11111:C0C1.0
	of 'dProofs15.txt'.
	Substitution is {(0,0), (1,1)}.
Found [3] : "CCC0.1.0.0" (originally "CCCpqpp")
	in line 510 - DDD1DDD1D1DDD1D111111DDD1D11111:CCC0.1.0.0
	of 'dProofs31.txt'.
	Substitution is {(0,0), (1,1)}.
Missing [2] : "CC0.1CC1.2C0.2" (originally "CCpqCCqrCpr"), [4] : "CC0C1.2CC0.1C0.2" (originally "CCpCqrCCpqCpr").

_{^{CCCpqrCCrpCsp,COp}}

$ ./pmGenerator -c -n -s CCCpqrCCrpCsp,COp --search Cpp,CpCqp,CCpqCCqrCpr,CCCpqpp,CCpCqrCCpqCpr,CCCpOCqOCqp,CCCpOpp,CpCCpOq -n -s -d
[...]
1097.39 ms (1 s 97.39 ms) taken to load and search 2547752 lines from 'dProofs79.txt'. [tid:22685440517696]
16229.18 ms (16 s 229.18 ms) taken to load and search 35197393 lines from 'dProofs81-unfiltered81+.txt'. [tid:22683949405760]
Search completed after 16232.60 ms (16 s 232.59 ms).
Found 4 of 8 formula schemas. Minimal results:
Found [0] : "C0.0" (originally "Cpp")
	in line 21 - DDDD1D11D1112:C0.0
	of 'dProofs13.txt'.
	Substitution is {(0,0)}.
Found [1] : "C0C1.0" (originally "CpCqp")
	in line 31 - DDD11DDD1D11111:C0C1.0
	of 'dProofs15.txt'.
	Substitution is {(0,0), (1,1)}.
Found [3] : "CCC0.1.0.0" (originally "CCCpqpp")
	in line 524 - DDD1DDD1D1DDD1D111111DDD1D11111:CCC0.1.0.0
	of 'dProofs31.txt'.
	Substitution is {(0,0), (1,1)}.
Found [6] : "CCC0O0.0" (originally "CCCpOpp")
	in line 524 - DDD1DDD1D1DDD1D111111DDD1D11111:CCC0.1.0.0
	of 'dProofs31.txt'.
	Substitution is {(0,0), (1,O)}.
Missing [2] : "CC0.1CC1.2C0.2" (originally "CCpqCCqrCpr"), [4] : "CC0C1.2CC0.1C0.2" (originally "CCpCqrCCpqCpr"), [5] : "CCC0OC1OC1.0" (originally "CCCpOCqOCqp"), [7] : "C0CC0O1" (originally "CpCCpOq").

The proportion of redundant instances of theorems that can be filtered out (but which requires significant computing power) is exceptionally high for these systems. For example, the exhaustively generated files dProofs81-unfiltered81+.txt and dProofs81.txt are ≈6.7 GiB (7,196,071,762 bytes; 32,747,235 proofs) and ≈746.2 MiB (782,466,043 bytes; 3,499,861 proofs) in size, respectively, for system CCCpqrCCrpCsp.

Filtered exponential growth factors (i.e. increases in file size between dProofs<n>.txt and dProofs<n+2>.txt) are near 1.47.

System CCCpqrCCrpCsp,COp generates 8493410 unique most general theorems with D-proofs of up to 79 steps. For CCCpqrCCrpCsp, this number is only 8161870.

GinoGiotto · 2026-05-27T00:13:15Z

GinoGiotto
May 27, 2026
Author

O is the standard symbol for falsum. My logic-structuralizer tool translates it to ⊥ accordingly; it has an example “ψ” to effortlessly display standard translations for all supported symbols.

My bad! I should have spent more time reading the documentation. The fact that pmGenerator already supports constant symbols is very convenient and it solves my feature request. The support for a family binary operators is also a nice feature that I might use later on.

Here is the MM1 proof of (a more general version of) ax-3 after a bit of compression with -x:

% ax_imp
CCCpqrCCrpCsp = 1

% ax_fal
COp = 2

% ax-3
[0] CCCpqCrOCrp = DDDDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D1111111DDDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDD1DDDD1D1D1D1DDDD1D1D1DDD1D1111111111D1DDD1D1DDD1D1111111DDDD1D1D1DDD1D111111111DDD1DDDD1D1D1D1DDDD1D1D1DDD1D1111111111D1DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D1111111112

The proof is 319 steps long and it uses ax_fal once at the end. In this form, one can indeed treat the system as 1-base, by compressing the implicational part of the proof and then attach the principle of explosion once finished. The natural step is to find shorter proofs that use ax_fal multiple times, but the fact that a "standard" version exists is already interesting to me.

I played with impsingle on my (slow and old) laptop last year for a few days. According to my notes, I used ...

In the last few days I attempted to use your method to find a further compression of ax-3, but I wasn't successfull. However I found other results within this system. The first is a shorter proof of id (which I just saw you posted shortly before me):

[0] Cpp = DDDD1D11D1112

The proof has 13 steps instead of the 21 I showed before. If I understand correctly, the -g composable command exhaustively generates all statements whose minimal proofs are shorter than a given length, since it eliminates longer redundant ones (unless the -u option is used). Therefore, the proof of id found in this way should be minimal. I did not initially thought that the minimal proof of id would use both axioms, since id only requires impsingle in principle.

The second result is a statistical one. With the command ./pmGenerator -c -n -s CCCpqrCCrpCsp,COp -g 57 I wrote all proofs up to 57 steps. Out of 175278 generated proofs, only 5637 use ax-fal, which is about 3.2% of them. It seems that the usage of the second axiom is somewhat rare, at least for short proofs. What's even more incredible is that only 24 proofs use ax-fal more than once. The shortest ones with such property are 49 steps long, here is one:

DD1DDDD1DDD1DDD1D1D1DDDD1D1D1111111DDD1D111111122: C0CCCO1O2

Corresponding to the statement:

|- ( p -> ( ( ( F. -> q ) -> F. ) -> r ) )

A feature of this system is the possibility of making predictions. In this example, since I know that the minimal proof of C0CCCO1O2 has 49 steps, I can infer that the minimal proof of the statement CC0.1C2CCC0.3.0.1 must have more than 45 steps, even without knowing the shape of the proof, because otherwise there would exist a shorter proof of C0CCCO1O2 obtained via the described method of discharging ax-fal. Perhaps each system has its own different tricks to extract information like this.

The example is very sensitive on data: It requires theorems of certain lengths with certain proof lengths to not be filtered out. In contrast, proof compression depends highly on which theorems are included.

Ok, so the method is system-dependent, which makes sense. I agree that generating lemmas with pmGenerator would yield higher quality data in general, so that's probably the strategy I should follow. Taking proofs from Metamath was more out of lazyness to get a quick starting point. Perhaps I will figure out some specialized methods like the ones seen on the challenges.

However, since you asked, I now started computing jobs to explore both CCCpqrCCrpCsp and CCCpqrCCrpCsp,COp at my university's computing cluster. I will report back interesting findings!

This is useful. I have a mediocre home computer and I haven’t investigated this system properly yet. University resources are very welcome.

The plan is to generate up to dProofs83.txt for both systems, then use -g -u on single nodes with 2 TiB memory until memory exhaustion, and then proceed depending on results.

This is indeed a lot better than what I did and could have done with my setup :)

Filtered exponential growth factors (i.e. increases in file size between dProofs.txt and dProofs<n+1>.txt) are near 1.47.

I can confirm that I observed a similar growth factor myself.

The proportion of redundant instances of theorems that can be filtered out (but which requires significant computing power) is exceptionally high for these systems.

How does it compare to Walsh and Meredith?

In regard to complexity, all 1-bases are overkill, and certainly more so than some 2-bases, which are certainly more overkill than some 3-bases, and so on.

The thing that made me interested is that, while technically 2-base, this system has some properties that makes it resemble a 1-base one (but with a shorter axiom). Apart from the ones I mentioned, there is also the impossibility of ax_fal to fill the major premise of modus ponens, because doing so would require |- F. to fill the minor premise:

min $e |- F.
maj $e |- ( F. -> ps )
ax-mp $p |- ps

In any proof of this 2-base system, ax_imp is the sole axiom that can fill the major premise. I am not aware of other commonly known systems with this property. In typical 2-base systems, both axioms can appear as either premise of modus ponens. In C-N systems, one could try a second axiom in the form |- -. ( ... ) so that it cannot unify with the major premise. The axiom would likely not be short since |- -. ( ... ) ultimately corresponds to a conjunction of two tautologies, but I am not even sure whether it would provide completeness.

1 reply

xamidi May 27, 2026
Maintainer

I did not initially thought that the minimal proof of id would use both axioms, since id only requires impsingle in principle.

Yeah, (0→1)→(1→1) conveniently has an 11-step proof DDD1D11D111, and the first part can be eliminated by detachment from the axiom ⊥→0.

There should be many similar cases where ax-fal enables shorter proofs.

How does it compare to Walsh and Meredith?

I deleted obsolete unfiltered files, but we can look into the log files. For Meredith's axiom, all the information can be obtained from dProofs69-unfiltered69+_48cpu.log and dProofs69_72node_3456cpu.log.

% log/custom/meredith-CCCCCpqCNrNsrtCCtpCsp/dProofs69-unfiltered69+_48cpu.log:165-166
Mon Oct  2 12:40:43 2023: Starting to write 14057500 entries to data/478804cd4793bc7f87041d99326aff4595662146d8a68175dda22bed/dProofs-withConclusions/dProofs69-unfiltered69+.txt.
11898.36 ms (11 s 898.36 ms) taken to print and save 2510775995 bytes of representative condensed detachment proof strings to data/478804cd4793bc7f87041d99326aff4595662146d8a68175dda22bed/dProofs-withConclusions/dProofs69-unfiltered69+.txt.

% log/custom/meredith-CCCCCpqCNrNsrtCCtpCsp/dProofs69_72node_3456cpu.log:574-575
Wed Oct  4 00:52:53 2023: Starting to write 9907537 entries to data/478804cd4793bc7f87041d99326aff4595662146d8a68175dda22bed/dProofs-withConclusions/dProofs69.txt.
4414.30 ms (4 s 414.31 ms) taken to print and save 1692424708 bytes of representative condensed detachment proof strings to data/478804cd4793bc7f87041d99326aff4595662146d8a68175dda22bed/dProofs-withConclusions/dProofs69.txt.

It shows that the exhaustively generated files dProofs69-unfiltered69+.txt and dProofs69.txt are ≈2.3 GiB (2,510,775,995 bytes; 14'057'500 proofs) and ≈1.6 GiB (1,692,424,708 bytes; 9'907'537 proofs) in size, respectively, for m.

I haven't uploaded the corresponding *-unfiltered* log files for Walsh’s axioms, but the comparison can at least be made regarding the numbers of proofs. For example,

% log/custom/walsh5-CCpqCCCrCstCqCNsNpCps/dProofs51_72node_3456cpu.log:354
157903.66 ms (2 min 37 s 903.66 ms) taken to read 4139577 condensed detachment proofs and conclusions from data/1d5f27494b1a2312e223b7f8dd3551abf717590ceef694c08dcbed72/dProofs-withConclusions/dProofs51-unfiltered51+.txt.

% log/custom/walsh5-CCpqCCCrCstCqCNsNpCps/dProofs51_72node_3456cpu.log:556
Tue Oct 24 13:26:57 2023: Starting to write 4101770 entries to data/1d5f27494b1a2312e223b7f8dd3551abf717590ceef694c08dcbed72/dProofs-withConclusions/dProofs51.txt.

shows that the exhaustively generated files dProofs51-unfiltered51+.txt and dProofs51.txt have 4'139'577 and 4'101'770 proofs, respectively, for w5. The difference is smallest for w5, closely followed by w2.

You can also see this by how much of a jump there is in “Recent Growth” for the uppermost unfiltered files — see the tables in the readme.

xamidi · 2026-06-19T23:27:12Z

xamidi
Jun 19, 2026
Maintainer

I emphasized in the readme that

This tool can generate and process exhaustive and refined proof collections. It is highly beneficial when different researchers share these files for their systems of interest with others to download and build upon.

and I am using this topic as an opportunity to demonstrate how this can be done, and to name just a few benefits.
On this occasion, I created the xamidi/pmData repository to host some of the files.

The process of providing initial proof data does not require much human effort — in fact, writing this comment took most of it in this case — but it tends to require a lot of computing time and patience. One can adjust the duration depending on how deep one chooses to prepare the data. Others can then dig deeper while not having to repeat computations.

1. Groundwork

In this case, I chose to exhaustively collect filtered proofs of up to 83 steps (based on close to 2× exponential growth and the fact that both filterings of dProofs83‑unfiltered83+.txt took more than 30k core-h each, which is significant for my 360k core-h per year computing time project). Then I collected unfiltered proofs until the available 2 TiB of RAM was fully utilized. In wall-clock time, all this took 171.9391666… h (7-3:56:21) for CCCpqrCCrpCsp and 214.6913888… h (8-22:41:29) for CCCpqrCCrpCsp,COp, not accounting for delays between computing jobs. These durations could have been reduced by activating the -b option for -g as long as memory requirements were sufficiently low and by splitting more of -g into -g -u with (multi-node) -m executions. But this also leads to more computing jobs and thereby to potentially more delays and increased human workload.

The aforementioned procedures took six computing jobs for each system:

Task	Multi- node?	Wall-clock time [h] `CCCpqrCCrpCsp`	Wall-clock time [h] `CCCpqrCCrpCsp,COp`
1. Use `-g -1` for up to a week. (Generated up to `dProofs79.txt`.)	no	129.6447222…	148.7358333…
2. Use `-g 81 -u` to generate `dProofs81-unfiltered81+.txt`.	no	0.9169444…	0.813888…
3. Use `-m 81` to generate `dProofs81.txt`	yes	2.696111…	3.0052777…
4. Use `-g 83 -u` to generate `dProofs83-unfiltered83+.txt`.	no	0.745	1.20111…
5. Use `-m 83` to generate `dProofs83.txt`	yes	5.4208333…	6.213888…
6. Use `-g -1 -u` until running out of memory. (Crashed after 93.)	no	32.51555…	54.7213888…

Note that the (low-memory) nodes with Intel Xeon Platinum 8468 CPUs turned out wasteful on computing time. So, since task 2 for CCCpqrCCrpCsp,COp, I switched to using the (high-memory) nodes with Intel Xeon Gold 6338 CPUs whenever possible.

A pitfall to avoid when starting with -g on many cores (96 in my case) is to not adjust !.conf to match the proof system's complexity. For example, the computing system may fail to correctly log many lines from many hardware threads at almost the same time. In my case, progress percentages were printed in the wrong order, and then the tasks failed with "basic_string: construction from null is not valid" exceptions within the first second of the computations. The solution is to enable progress printing only for proof lengths that are sufficiently high and then start over. I modified !.conf by adding 10 to all the default barriers.

2. Takeoff

The 119-step proof of L1:CCpqCCqrCpr that I mentioned in an earlier comment uses theorems that consist of at most 35 symbols, and all of its subproofs longer than 29 steps result in theorems of at most 19 symbols, except for two theorems of 27 and 29 symbols.

_{^{119-step proof of L1:CCpqCCqrCpr in detail}}

$ pmGenerator --transform CCCpqrCCrpCsp=1,[0]=DDDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111D1DDD11DDD1D111111111DDDD1D1D1DDD1D1111111 -w -n -t _ -p -2 -d
[…]
There are 119 steps towards CCpqCCqrCpr / CC0.1CC1.2C0.2 (index 0).
There are 3 steps towards CCCCpqCrqCqsCtCqs / CCCC0.1C2.1C1.3C4C1.3 (index 1).
There are 5 steps towards CCCpCqrCCsqCtqCuCCsqCtq / CCC0C1.2CC3.1C4.1C5CC3.1C4.1 (index 2).
There are 7 steps towards CCCpCCqrCsrCtCruCvCtCru / CCC0CC1.2C3.2C4C2.5C6C4C2.5 (index 3).
There are 7 steps towards CpCCCqrqCsq / C0CCC1.2.1C3.1 (index 4).
There are 9 steps towards CpCCCCqrCsrtCrt / C0CCCC1.2C3.2.4C2.4 (index 5).
There are 9 steps towards CCCpqpCrp / CCC0.1.0C2.0 (index 6).
There are 11 steps towards CCCpqCqrCsCqr / CCC0.1C1.2C3C1.2 (index 7).
There are 13 steps towards CpCqCrq / C0C1C2.1 (index 8).
There are 11 steps towards CCCCpqCrqsCqs / CCCC0.1C2.1.3C1.3 (index 9).
There are 13 steps towards CCCpCqrCsqCtCsq / CCC0C1.2C3.1C4C3.1 (index 10).
There are 15 steps towards CpCqp / C0C1.0 (index 11).
There are 13 steps towards CpCCCqprCsr / C0CCC1.0.2C3.2 (index 12).
There are 15 steps towards CCCpCqrCsCrtCuCsCrt / CCC0C1.2C3C2.4C5C3C2.4 (index 13).
There are 17 steps towards CCCpCqrqCsq / CCC0C1.2.1C3.1 (index 14).
There are 15 steps towards CCCCCpCqrsCtsqCuq / CCCCC0C1.2.3C4.3.1C5.1 (index 15).
There are 17 steps towards CCCpqCCCrCqstCutCvCCCrCqstCut / CCC0.1CCC2C1.3.4C5.4C6CCC2C1.3.4C5.4 (index 16).
There are 17 steps towards CpCCCqrsCrs / C0CCC1.2.3C2.3 (index 17).
There are 19 steps towards CCCpCCCqCrstCutCvrCwCvr / CCC0CCC1C2.3.4C5.4C6.2C7C6.2 (index 18).
There are 19 steps towards CCCpqrCqr / CCC0.1.2C1.2 (index 19).
There are 21 steps towards CCCpCqrCsCCCtCruvCwvCxCsCCCtCruvCwv / CCC0C1.2C3CCC4C2.5.6C7.6C8C3CCC4C2.5.6C7.6 (index 20).
There are 21 steps towards CpCCpqCrq / C0CC0.1C2.1 (index 21).
There are 23 steps towards CCCpCqCCCrCstuCvuCwCxsCyCwCxs / CCC0C1CCC2C3.4.5C6.5C7C8.3C9C7C8.3 (index 22).
There are 25 steps towards CpCCCqCCCrCstuCvusCws / C0CCC1CCC2C3.4.5C6.5.3C7.3 (index 23).
There are 27 steps towards CCCpCCCqCrstCutrCvr / CCC0CCC1C2.3.4C5.4.2C6.2 (index 24).
There are 29 steps towards CCCpqCrCCCsCqtuCvuCwCrCCCsCqtuCvu / CCC0.1C2CCC3C1.4.5C6.5C7C2CCC3C1.4.5C6.5 (index 25).
There are 31 steps towards CpCCqCrsCCCtCqusCrs / C0CC1C2.3CCC4C1.5.3C2.3 (index 26).
There are 33 steps towards CCpCqrCCCsCptrCqr / CC0C1.2CCC3C0.4.2C1.2 (index 27).
There are 51 steps towards CCCpCCCqCrsrtrCur / CCC0CCC1C2.3.2.4.2C5.2 (index 28).
There are 53 steps towards CCCpqCrCCCsCqtquCvCrCCCsCqtqu / CCC0.1C2CCC3C1.4.1.5C6C2CCC3C1.4.1.5 (index 29).
There are 55 steps towards CpCCqrCCCsCqtqr / C0CC1.2CCC3C1.4.1.2 (index 30).
There are 57 steps towards CCpqCCCrCpspq / CC0.1CCC2C0.3.0.1 (index 31).
There are 91 steps towards CCCpCCqrsrCCCtCquqr / CCC0CC1.2.3.2CCC4C1.5.1.2 (index 32).
There are 93 steps towards CCCCCpCqrqsCtCCqsuCvCtCCqsu / CCCCC0C1.2.1.3C4CC1.3.5C6C4CC1.3.5 (index 33).
There are 95 steps towards CpCCqCrCstCCsqCrCst / C0CC1C2C3.4CC3.1C2C3.4 (index 34).
There are 97 steps towards CCpCqCrsCCrpCqCrs / CC0C1C2.3CC2.0C1C2.3 (index 35).
[…]
    CCCpqrCCrpCsp = 1
[0] CCCCpqCrqCqsCtCqs = D11
[1] CCCpCqrCCsqCtqCuCCsqCtq = D1[0]
[2] CCCpCCqrCsrCtCruCvCtCru = D1[1]
[3] CpCCCCqrCsrtCrt = D[2]1
[4] CCCCpqCrqsCqs = D[3]1
[5] CpCCCqprCsr = D[4]1
[6] CCCCCpCqrsCtsqCuq = D1[5]
[7] CCCpqCCCrCqstCutCvCCCrCqstCut = D1[6]
[8] CCCpCCCqCrstCutCvrCwCvr = D1[7]
[9] CCCpCqrCsCCCtCruvCwvCxCsCCCtCruvCwv = D1[8]
[10] CCCpCqCCCrCstuCvuCwCxsCyCwCxs = D1[9]
[11] CpCCCqCCCrCstuCvusCws = D[10]1
[12] CCCpCCCqCrstCutrCvr = D[11]1
[13] CCCpqCrCCCsCqtuCvuCwCrCCCsCqtuCvu = D1[12]
[14] CpCCqCrsCCCtCqusCrs = D[13]1
[15] CCpCqrCCCsCptrCqr = D[14]1
[16] CpCCCqrqCsq = D[1]1
[17] CCCpqpCrp = D[16]1
[18] CpCqCrq = D[0][17]
[19] CpCqp = D[18]1
[20] CCCpCqrqCsq = D1[19]
[21] CCCpCCCqCrsrtrCur = D[15][20]
[22] CCCpqCrCCCsCqtquCvCrCCCsCqtqu = D1[21]
[23] CpCCqrCCCsCqtqr = D[22]1
[24] CCpqCCCrCpspq = D[23]1
[25] CCCpCCqrsrCCCtCquqr = D[15][24]
[26] CCCCCpCqrqsCtCCqsuCvCtCCqsu = D1[25]
[27] CpCCqCrCstCCsqCrCst = D[26]1
[28] CCpCqCrsCCrpCqCrs = D[27]1
[29] CCCpqCqrCsCqr = D1[17]
[30] CCCpCqrCsqCtCsq = D1[29]
[31] CCCpCqrCsCrtCuCsCrt = D1[30]
[32] CpCCCqrsCrs = D[31]1
[33] CCCpqrCqr = D[32]1
[34] CpCCpqCrq = D[33]1
[35] CCpqCCqrCpr = D[28][34]

Given this proof and the way it was discovered, it seems reasonable to assume that limiting new conclusions to 40 symbols for proofs longer than 93 steps would not result in too much of a loss.

I extracted from exhaustive data via --extract -l 40^✻, renamed the resulting folders into extraction-l40, filtered the new dProofs{85,…,93}‑unfiltered85+.txt files via -m, and continued with -g -1 -l 40 -b^❈ — or -g 111 -l 40 -b for CCCpqrCCrpCsp,COp after it turned out that computing files higher than dProofs111.txt in this way would again become too expensive.

So I copied extraction-l40 to extraction-l40l30 and continued with -g 223 -l 30. I chose 223 as a limit since a D-proof having proper subproofs of at most 111 steps can have at most 223 steps, and I wanted to at least know whether any two theorems in up to dProofs111.txt can be combined to prove something useful, e.g. A2:CCpCqrCCpqCpr or A3_C-O:CCCpOCqOCqp. This again proved to be unreasonably time-consuming. But the process can be sped up significantly, at least for smaller theorems, by using smaller extractions.

Consequently, rather than just waiting for expensive generations (that I now, a month in, chose to upload in part), I extracted via --extract -l 21 from extraction-l40l30, replaced dProofs{1,…,41}.txt with the -l 40 variants, and then used -g -1 -l 21 -b. These calculations were performed successively for both systems on my old PC with an Intel Core i7-3770 CPU. First, the generation for CCCpqrCCrpCsp,COp obtained nine files dProofs{143,…,159}.txt in less than 3 hours, after which I found a 155-step proof for A3_C-O. Next, the generation for CCCpqrCCrpCsp obtained forty-three files dProofs{155,…,239}.txt in just over 15.2 hours, after which I found a 239-step proof for A2.

^✻_{I also started to build -l 50 extractions in this way, but abandoned them after using -m on the unfiltered files turned out not to be worth it for me.}

^❈_{This also revealed a 101-step proof for L1:CCpqCCqrCpr, and a 111-step proof for L3_C-O:CpCCpOq.}

3. Ascent

Now we have short derivations towards the (much easier to handle) classical C-O system P₁:CpCqp,CCpCqrCCpqCpr,CCCpOOp, which is addressed in part 24 of the “On axiom systems of propositional calculi” paper series, and towards the C-O variants of the classical C-N systems L₁:CCpqCCqrCpr,CCNppp,CpCNpq and L₃:CpCqp,CCpCqrCCpqCpr,CCNpNqCqp. Notably, these initial results were obtained without the use of proof compression. The data can now be mined for useful connections to potentially shorten these results even further and to minimize new derivations much more effectively (and potentially find them with --rebase) — as detailed in the first local PMC. Mostly by collecting proofs to use ./pmGenerator --transform -x, ./searchShorterSubproofs (or ./pmGenerator -c -n -s CCCpqrCCrpCsp[,COp] -e […] --search), and continued partial generations, I think.

Identifier(s)	C-O	C-N	Typical Axiom in Fragment(s)
A1, P₁:`1`, L₃:`1`	`CpCqp`	⇠	C, C-N, C-O
A2, P₁:`2`, L₃:`2`	`CCpCqrCCpqCpr`	⇠	C, C-N, C-O
P₁:`3`	`CCCpOOp`	`CNNpp`	C-N, C-O
L1, L₁:`1`	`CCpqCCqrCpr`	⇠	C, C-N, C-O
L2, L₁:`2`	`CCCpOpp`	`CCNppp`	C-N
L3, L₁:`3`	`CpCCpOq`	`CpCNpq`	C-N
A3, L₃:`3`	`CCCpOCqOCqp`	`CCNpNqCqp`	C-N

(Reminder: If you prefer to read infix notation, you can use my converter.)

Note that L2_C-O is proven without COp as its proper schema CCCpqpp (Peirce's law), which is often used in axiomatizations of the classical C fragment, i.e. implicational logic. It is addressed within I₁: CpCqp,CCpqCCqrCpr,CCCpqpp = (A1, L1, Peirce's law) and I₅:CCpqCCqrCpr,CCCpqpp,CpCCpqq = (A1, Peirce's law, CpCCpqq) in parts 14 and 25 of the previously mentioned paper series.

Initial Results

^{I will update the pmData repository in case of improvements, not this comment.}

`CCCpqrCCrpCsp`

^{The shortest single axiom for classical implicational logic.}

Hash: 97553789db1645226627da044ed0a2e6a9cfd5963d66a8a44e121146 [i.e. SHA512/224("CCC0.1.2CC2.0C3.0")]
System: CCCpqrCCrpCsp [i.e. 1:((p→q)→r)→((r→p)→(s→p))]

Fingerprint

^{_{[grayscale] [raw]}}

Data

Files up to..	Size of Files [B]	+Costs [≈core‑h]	Recent Growth
^{_{dProofs81.txt}}	2 449 297 774	15529.60	1.4706…
^{_{dProofs83.txt}}	3 597 241 733	31224.00	1.4670…
^{_{dProofs85‑unfiltered85+.txt}}	19 626 102 482	69.15	13.9631…
^{_{dProofs87‑unfiltered85+.txt}}	60 909 402 788	130.28	2.5755…
^{_{dProofs89‑unfiltered85+.txt}}	153 150 493 111	271.16	2.2343…
^{_{dProofs91‑unfiltered85+.txt}}	320 324 295 368	518.62	1.8123…
^{_{dProofs93‑unfiltered85+.txt}}	649 288 832 712	1039.80	1.9677…

Smallest 10k theorems (with minimal proofs): top10000SmallestConclusions_1to93Steps.txt (1.640806 MB)
- Includes all up-to-19-symbol theorems that can be generated in up to 93 steps.

Cardinalities

         1 dProofs3.txt
         1 dProofs5.txt
         3 dProofs7.txt
         8 dProofs9.txt
        14 dProofs11.txt
        21 dProofs13.txt
        31 dProofs15.txt
        42 dProofs17.txt
        65 dProofs19.txt
        98 dProofs21.txt
       135 dProofs23.txt
       197 dProofs25.txt
       270 dProofs27.txt
       388 dProofs29.txt
       551 dProofs31.txt
       783 dProofs33.txt
      1106 dProofs35.txt
      1563 dProofs37.txt
      2211 dProofs39.txt
      3116 dProofs41.txt
      4400 dProofs43.txt
      6223 dProofs45.txt
      8774 dProofs47.txt
     12413 dProofs49.txt
     17529 dProofs51.txt
     24829 dProofs53.txt
     35088 dProofs55.txt
     49805 dProofs57.txt
     70539 dProofs59.txt
    100323 dProofs61.txt
    142420 dProofs63.txt
    202794 dProofs65.txt
    288534 dProofs67.txt
    411654 dProofs69.txt
    586547 dProofs71.txt
    837981 dProofs73.txt
   1196203 dProofs75.txt
   1710627 dProofs77.txt
   2444582 dProofs79.txt
   3499861 dProofs81.txt
   5006994 dProofs83.txt
  68838412 dProofs85-unfiltered85+.txt
 170845717 dProofs87-unfiltered85+.txt
 335691857 dProofs89-unfiltered85+.txt
 584703462 dProofs91-unfiltered85+.txt
1060815488 dProofs93-unfiltered85+.txt

Extracted & Partially Generated

(--extract -l 50)-dProofs1-93-unfiltered91+ (Folder: extraction-l50)
- Up to dProofs89.txt were created via -m from -l 50-extractions of exhaustive files, thus are complete w.r.t. -l 50 entries.
- The remaining unfiltered files (dProofs{91,93}-unfiltered85+.txt) must be renamed to be loaded by pmGenerator.
(--extract -l 40)-dProofs1-93-(-g -l 40)-111-(-g -l 30)-153 (Folder: extraction-l40l30)
- Up to dProofs93.txt were created via -m from -l 40-extractions of exhaustive files, thus are complete w.r.t. -l 40 entries.
- Smallest 24820 theorems (with proofs): l40l30-top24820SmallestConclusions_1to153Steps.txt (4.661867 MB)
  - Includes all generated up-to-19-symbol theorems. All proofs with up to 95 steps are minimal.
- Smallest 76307 theorems (with proofs): l40l30-top76307SmallestConclusions_1to153Steps.txt (15.172891 MB)
  - Includes all generated up-to-21-symbol theorems. All proofs with up to 95 steps are minimal.
(--extract -l 40)-dProofs1-41-(-e l40l30 --extract -l 21)-153-(-g -l 21)-239 (Folder: extraction-l21)
- Exemplary search:
```
pmGenerator -c -n -s CCCpqrCCrpCsp -e l21 --search Cpp,CpCqp,CCpCqrCCpqCpr,CCpqCCqrCpr,CCCpOpp,CCCpqpp -n -s
```

Exemplary Proofs

Concrete D-proofs / “Proof List”

% Identity principle (Cpp), i.e. 0→0 ; 21 steps
DDDDD1D1111DDD1D11111,
% Axiom 1 by Frege (CpCqp), i.e. 0→(1→0) ; 15 steps
DDD11DDD1D11111,
% Axiom 2 by Frege (CCpCqrCCpqCpr), i.e. (0→(1→2))→((0→1)→(0→2)) ; 239 steps
DDDD1D1D1DDDDDD1D1D1D1DDDD1D1D111111111DDDDD1D1D1D1DDDD1D1D11111111111DDD1DDDDDD1D1D1D1DDDD1D1D1111111111D1DDDDDD1D1D1D1DDDD1D1D111111111DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D1111111111111,
% Axiom 1 by Łukasiewicz (CCpqCCqrCpr), i.e. (0→1)→((1→2)→(0→2)) ; 101 steps
DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D111111111111,
% Axiom 2 by Łukasiewicz (CCCpOpp [C-N: CCNppp]), i.e. ((0→⊥)→0)→0 [C-N: (¬0→0)→0], instance of:
% Peirce's law (CCCpqpp), i.e. ((p→q)→p)→p ; 31 steps
DDD1DDD1D1DDD1D111111DDD1D11111

Exemplary parse:

pmGenerator -c -n -s CCCpqrCCrpCsp --parse proofList.txt -f -u -j 1
pmGenerator -c -n -s CCCpqrCCrpCsp --parse DDDDD1D1111DDD1D11111,DDD11DDD1D11111,DDDD1D1D1DDDDDD1D1D1D1DDDD1D1D111111111DDDDD1D1D1D1DDDD1D1D11111111111DDD1DDDDDD1D1D1D1DDDD1D1D1111111111D1DDDDDD1D1D1D1DDDD1D1D111111111DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D1111111111111,DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D111111111111,DDD1DDD1D1DDD1D111111DDD1D11111 -u -j 1

Abstract Representation / “Proof Summary”

    CCCpqrCCrpCsp = 1
[0] CCCpqpCrp = DDD1D1111
[1] CpCqp = DDD11[0]1
[2] Cpp = DD[0][0]1
[3] CCpCqrCCCpsrCqr = DDDDD1D1D1D1DDDD1D1D111111111
[4] CCCpqpp = DDD1DDD1D1[0]11[0]1
[5] CCpqCCqrCpr = DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1[0]11111111
[6] CCpCqrCCpqCpr = DDDD1D1D1D[3][3]11DDD1D[3]1D1D[3][5]1

Exemplary transform:

pmGenerator --transform proofSummary.txt -f -n -t Cpp,CpCqp,CCpCqrCCpqCpr,CCpqCCqrCpr,CCCpqpp -p -2 -d
pmGenerator --transform "CCCpqrCCrpCsp=1,[0]=DDD1D1111,[1]=DDD11[0]1,[2]=DD[0][0]1,[3]=DDDDD1D1D1D1DDDD1D1D111111111,[4]=DDD1DDD1D1[0]11[0]1,[5]=DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1[0]11111111,[6]=DDDD1D1D1D[3][3]11DDD1D[3]1D1D[3][5]1" -n -w -t Cpp,CpCqp,CCpCqrCCpqCpr,CCpqCCqrCpr,CCCpqpp -p -2 -d

`CCCpqrCCrpCsp,COp`

^{The shortest single axiom for classical implicational logic, together with the principle of explosion. They axiomatizatize classical propositional logic in terms of {→,⊥}.}

Hash: d099134db97a750df3c662fb6ffa88c2d84bc409e4109a48410d25f9 [i.e. SHA512/224("CCC0.1.2CC2.0C3.0CO0")]
System: CCCpqrCCrpCsp,COp [i.e. 1:((p→q)→r)→((r→p)→(s→p)), 2:⊥→p]

Fingerprint

^{_{[grayscale] [raw]}}

Data

Files up to..	Size of Files [B]	+Costs [≈core‑h]	Recent Growth
^{_{dProofs81.txt}}	2 531 886 162	17310.40	1.4742…
^{_{dProofs83.txt}}	3 719 804 925	35792.00	1.4655…
^{_{dProofs85‑unfiltered85+.txt}}	20 719 453 444	112.69	14.3104…
^{_{dProofs87‑unfiltered85+.txt}}	64 772 912 668	213.68	2.5914…
^{_{dProofs89‑unfiltered85+.txt}}	163 246 801 423	434.06	2.2353…
^{_{dProofs91‑unfiltered85+.txt}}	341 553 471 625	881.99	1.8106…
^{_{dProofs93‑unfiltered85+.txt}}	691 422 259 426	1815.61	1.9621…

Smallest 10k theorems (with minimal proofs): top10000SmallestConclusions_1to93Steps.txt (1.622864 MB)
- Includes all up-to-17-symbol theorems that can be generated in up to 93 steps.

Cardinalities

         2 dProofs1.txt
         1 dProofs3.txt
         1 dProofs5.txt
         3 dProofs7.txt
         8 dProofs9.txt
        15 dProofs11.txt
        22 dProofs13.txt
        33 dProofs15.txt
        45 dProofs17.txt
        69 dProofs19.txt
       101 dProofs21.txt
       140 dProofs23.txt
       205 dProofs25.txt
       280 dProofs27.txt
       404 dProofs29.txt
       568 dProofs31.txt
       809 dProofs33.txt
      1140 dProofs35.txt
      1614 dProofs37.txt
      2278 dProofs39.txt
      3217 dProofs41.txt
      4529 dProofs43.txt
      6426 dProofs45.txt
      9042 dProofs47.txt
     12829 dProofs49.txt
     18076 dProofs51.txt
     25667 dProofs53.txt
     36224 dProofs55.txt
     51530 dProofs57.txt
     72889 dProofs59.txt
    103901 dProofs61.txt
    147416 dProofs63.txt
    210360 dProofs65.txt
    299183 dProofs67.txt
    427694 dProofs69.txt
    609264 dProofs71.txt
    872065 dProofs73.txt
   1244628 dProofs75.txt
   1782980 dProofs77.txt
   2547752 dProofs79.txt
   3653261 dProofs81.txt
   5226411 dProofs83.txt
  74024284 dProofs85-unfiltered85+.txt
 185049299 dProofs87-unfiltered85+.txt
 364350012 dProofs89-unfiltered85+.txt
 633578953 dProofs91-unfiltered85+.txt
1146953429 dProofs93-unfiltered85+.txt

Extracted & Partially Generated

(--extract -l 50)-dProofs1-93-unfiltered85+ (Folder: extraction-l50)
(--extract -l 40)-dProofs1-93-(-g -l 40)-111-(-g -l 30)-141 (Folder: extraction-l40l30)
- Up to dProofs93.txt were created via -m from -l 40-extractions of exhaustive files, thus are complete w.r.t. -l 40 entries.
- Smallest 42679 theorems (with proofs): l40l30-top42679SmallestConclusions_1to141Steps.txt (7.851301 MB)
  - Includes all generated up-to-19-symbol theorems. All proofs with up to 95 steps are minimal.
- Smallest 124246 theorems (with proofs): l40l30-top124246SmallestConclusions_1to141Steps.txt (24.082907 MB)
  - Includes all generated up-to-21-symbol theorems. All proofs with up to 95 steps are minimal.

(--extract -l 40)-dProofs1-41-(-e l40l30 --extract -l 21)-141-(-g -l 21)-159 (Folder: extraction-l21)

Exemplary search:

pmGenerator -c -n -s CCCpqrCCrpCsp,COp -e l21 --search Cpp,CpCqp,CCpCqrCCpqCpr,CCCpOOp,CCCpqOp,CCpqCCqrCpr,CCCpOpp,CCCpqpp,CpCCpOq,CCCpOCqOCqp,CCCpqCrOCrp -n -s

Exemplary Proofs

Concrete D-proofs / “Proof List”

% Identity principle (Cpp), i.e. 0→0 ; 13 steps
DDDD1D11D1112,
% Axiom 1 by Frege (CpCqp), i.e. 0→(1→0) ; 15 steps
DDD11DDD1D11111,
% Axiom 2 by Frege (CCpCqrCCpqCpr), i.e. (0→(1→2))→((0→1)→(0→2)) ; 239 steps
DDDD1D1D1DDDDDD1D1D1D1DDDD1D1D111111111DDDDD1D1D1D1DDDD1D1D11111111111DDD1DDDDDD1D1D1D1DDDD1D1D1111111111D1DDDDDD1D1D1D1DDDD1D1D111111111DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D1111111111111,
% Double negation elimination (CCCpOOp [C-N: CNNpp]), i.e. ((0→⊥)→⊥)→0 [C-N: ¬¬0→0], instance of:
% CCCpqOp, i.e. ((0→1)→⊥)→0 ; 31 steps
DDDD1DDD1D1DDDD1D1D11111D111112,
% Axiom 1 by Łukasiewicz (CCpqCCqrCpr), i.e. (0→1)→((1→2)→(0→2)) ; 101 steps
DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D111111111111,
% Axiom 2 by Łukasiewicz (CCCpOpp [C-N: CCNppp]), i.e. ((0→⊥)→0)→0 [C-N: (¬0→0)→0], instance of:
% Peirce's law (CCCpqpp), i.e. ((p→q)→p)→p ; 31 steps
DDD1DDD1D1DDD1D111111DDD1D11111,
% Axiom 3 by Łukasiewicz (CpCCpOq [C-N: CpCNpq]), i.e. 0→((0→⊥)→1) [C-N: 0→(¬0→1)] ; 111 steps
DDDD1DDD1D1DDDD1D1D11111DDDD1D1D1DDDDDD1D1D1D1DDDD1D1D111111111111D1DDDDDD1DDD1D1D1D1D1DDDD1D1D1111111111121112,
% Axiom 3 for Frege by Łukasiewicz (CCCpOCqOCqp [C-N: CCNpNqCqp]), i.e. ((0→⊥)→(1→⊥))→(1→0) [C-N: (¬0→¬1)→(1→0)], instance of:
% CCCpqCrOCrp, i.e. ((0→1)→(2→⊥))→(2→0) ; 155 steps
DDD1DDDDDD1D1D1D1DDDD1D1D1111111111DDDDDD1D1D1D1DDDD1D1D111111111DDDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D11111111121

Exemplary parse:

pmGenerator -c -n -s CCCpqrCCrpCsp,COp --parse proofList.txt -f -u -j 1
pmGenerator -c -n -s CCCpqrCCrpCsp,COp --parse DDDD1D11D1112,DDD11DDD1D11111,DDDD1D1D1DDDDDD1D1D1D1DDDD1D1D111111111DDDDD1D1D1D1DDDD1D1D11111111111DDD1DDDDDD1D1D1D1DDDD1D1D1111111111D1DDDDDD1D1D1D1DDDD1D1D111111111DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D1111111111111,DDDD1DDD1D1DDDD1D1D11111D111112,DDDD1D1D1D1DDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D111111111111,DDD1DDD1D1DDD1D111111DDD1D11111,DDDD1DDD1D1DDDD1D1D11111DDDD1D1D1DDDDDD1D1D1D1DDDD1D1D111111111111D1DDDDDD1DDD1D1D1D1D1DDDD1D1D1111111111121112,DDD1DDDDDD1D1D1D1DDDD1D1D1111111111DDDDDD1D1D1D1DDDD1D1D111111111DDDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D11111111121 -u -j 1

Abstract Representation / “Proof Summary”

    CCCpqrCCrpCsp = 1
    COp = 2
[0] Cpp = DDDD1D11D1112
[1] CpCqp = DDD11DDD1D11111
[2] CCCpqCCCrCqstCutCvCCCrCqstCut = D1D1DDDD1D1D11111
[3] CCpCqrCCCpsrCqr = DDDDD1D1[2]1111
[4] CCCpqpp = DDD1DDD1D1DDD1D111111DDD1D11111
[5] CCCpqOp = DDDD1DD[2]D111112
[6] CCpCqCrsCCrpCqCrs = DDD1DDDD1DDD1D1D1[2]1111DDD1DDD1DDD1[2]11D1D1DDD1D111111111
[7] CCpqCCqrCpr = DDDD1D1D1D1[6]111
[8] CpCCpOq = DDDD1DD[2]DDDD1D1D1D[3]111D1DDDDDD1DDD1D1D1[2]11111121112
[9] CCCpqCrOCrp = DDD1D[3]1D[3]D[6]21
[10] CCpCqrCCpqCpr = DDDD1D1D1D[3][3]11DDD1D[3]1D1D[3][7]1

Exemplary transform:

pmGenerator --transform proofSummary.txt -f -n -t Cpp,CpCqp,CCCpqpp,CCCpqOp,CCpqCCqrCpr,CpCCpOq,CCCpqCrOCrp,CCpCqrCCpqCpr -p -2 -d
pmGenerator --transform "CCCpqrCCrpCsp=1,COp=2,[0]=DDDD1D11D1112,[1]=DDD11DDD1D11111,[2]=D1D1DDDD1D1D11111,[3]=DDDDD1D1[2]1111,[4]=DDD1DDD1D1DDD1D111111DDD1D11111,[5]=DDDD1DD[2]D111112,[6]=DDD1DDDD1DDD1D1D1[2]1111DDD1DDD1DDD1[2]11D1D1DDD1D111111111,[7]=DDDD1D1D1D1[6]111,[8]=DDDD1DD[2]DDDD1D1D1D[3]111D1DDDDDD1DDD1D1D1[2]11111121112,[9]=DDD1D[3]1D[3]D[6]21,[10]=DDDD1D1D1D[3][3]11DDD1D[3]1D1D[3][7]1" -n -w -t Cpp,CpCqp,CCCpqpp,CCCpqOp,CCpqCCqrCpr,CpCCpOq,CCCpqCrOCrp,CCpCqrCCpqCpr -p -2 -d

Comparison: `CCCpqrCCrpCsp` vs. `CCCpqrCCrpCsp,COp`

^{This section is part of pmData/CCCpqrCCrpCsp,COp.
#₁⬚ means number of ⬚ w.r.t. CCCpqrCCrpCsp; #₂⬚ means number of ⬚ w.r.t. CCCpqrCCrpCsp,COp. F stands for derived formulas.}

_{^{Full table: Σ_filtered}}

	#₁F	#₂F	ΔF	#₁`C`	#₂`C`	#₁`1`	#₂`1`	#₂`2`	#₂`O`
_dProofs1.txt	₁	₂	₊₁	₆	₇	₁	₁	₁	₁
_dProofs3.txt	₁	₁	₀	₈	₈	₂	₂	₀	₀
_dProofs5.txt	₁	₁	₀	₁₁	₁₁	₃	₃	₀	₀
_dProofs7.txt	₃	₃	₀	₂₁	₂₁	₁₂	₁₂	₀	₀
_dProofs9.txt	₈	₈	₀	₅₃	₅₃	₄₀	₄₀	₀	₀
_{dProofs11.txt}	₁₄	₁₅	₊₁	₁₁₃	₁₁₅	₈₄	₈₉	₁	₁
_{dProofs13.txt}	₂₁	₂₂	₊₁	₁₈₁	₁₈₀	₁₄₇	₁₅₂	₂	₁
_{dProofs15.txt}	₃₁	₃₃	₊₂	₃₁₂	₃₂₅	₂₄₈	₂₆₁	₃	₆
_{dProofs17.txt}	₄₂	₄₅	₊₃	₄₇₇	₄₉₆	₃₇₈	₄₀₁	₄	₇
_{dProofs19.txt}	₆₅	₆₉	₊₄	₇₇₉	₈₀₁	₆₅₀	₆₈₆	₄	₄
_{dProofs21.txt}	₉₈	₁₀₁	₊₃	₁₂₃₈	₁₂₇₃	₁₀₇₈	₁₁₀₇	₄	₇
_{dProofs23.txt}	₁₃₅	₁₄₀	₊₅	₁₉₅₅	₁₉₉₇	₁₆₂₀	₁₆₇₅	₅	₆
_{dProofs25.txt}	₁₉₇	₂₀₅	₊₈	₃₀₉₃	₃₁₈₂	₂₅₆₁	₂₆₅₇	₈	₁₅
_{dProofs27.txt}	₂₇₀	₂₈₀	₊₁₀	₄₆₀₃	₄₇₀₀	₃₇₈₀	₃₉₁₀	₁₀	₁₂
_{dProofs29.txt}	₃₈₈	₄₀₄	₊₁₆	₇₀₁₇	₇₂₃₁	₅₈₂₀	₆₀₄₄	₁₆	₃₀
_{dProofs31.txt}	₅₅₁	₅₆₈	₊₁₇	₁₀₅₈₃	₁₀₇₇₄	₈₈₁₆	₉₀₇₁	₁₇	₂₁
_{dProofs33.txt}	₇₈₃	₈₀₉	₊₂₆	₁₅₈₈₇	₁₆₂₈₇	₁₃₃₁₁	₁₃₇₂₇	₂₆	₄₇
_{dProofs35.txt}	₁₁₀₆	₁₁₄₀	₊₃₄	₂₃₇₆₉	₂₄₂₂₄	₁₉₉₀₈	₂₀₄₈₆	₃₄	₄₄
_{dProofs37.txt}	₁₅₆₃	₁₆₁₄	₊₅₁	₃₅₄₃₄	₃₆₃₄₇	₂₉₆₉₇	₃₀₆₁₅	₅₁	₉₆
_{dProofs39.txt}	₂₂₁₁	₂₂₇₈	₊₆₇	₅₂₅₂₇	₅₃₅₃₄	₄₄₂₂₀	₄₅₄₉₃	₆₇	₉₁
_{dProofs41.txt}	₃₁₁₆	₃₂₁₇	₊₁₀₁	₇₇₄₇₆	₇₉₄₅₉	₆₅₄₃₆	₆₇₄₅₆	₁₀₁	₁₈₂
_{dProofs43.txt}	₄₄₀₀	₄₅₂₉	₊₁₂₉	₁₁₄₂₇₁	₁₁₆₅₁₄	₉₆₈₀₀	₉₉₅₀₉	₁₂₉	₁₈₂
_{dProofs45.txt}	₆₂₂₃	₆₄₂₆	₊₂₀₃	₁₆₈₆₅₀	₁₇₃₀₃₄	₁₄₃₁₂₉	₁₄₇₅₉₅	₂₀₃	₃₇₃
_{dProofs47.txt}	₈₇₇₄	₉₀₄₂	₊₂₆₈	₂₄₇₂₀₆	₂₅₂₂₁₁	₂₁₀₅₇₆	₂₁₆₇₄₀	₂₆₈	₃₉₅
_{dProofs49.txt}	₁₂₄₁₃	₁₂₈₂₉	₊₄₁₆	₃₆₃₅₂₂	₃₇₃₀₆₃	₃₁₀₃₂₅	₃₂₀₃₀₇	₄₁₈	₇₅₅
_{dProofs51.txt}	₁₇₅₂₉	₁₈₀₇₆	₊₅₄₇	₅₃₁₆₃₀	₅₄₂₈₁₄	₄₅₅₇₅₄	₄₆₉₄₂₅	₅₅₁	₈₃₂
_{dProofs53.txt}	₂₄₈₂₉	₂₅₆₆₇	₊₈₃₈	₇₈₀₈₆₇	₈₀₁₅₆₅	₆₇₀₃₈₃	₆₉₂₁₆₈	₈₄₁	₁₅₄₁
_{dProofs55.txt}	₃₅₀₈₈	₃₆₂₂₄	₊₁₁₃₆	_1140459	_1165544	₉₈₂₄₆₄	_1013125	₁₁₄₇	₁₇₉₉
_{dProofs57.txt}	₄₉₈₀₅	₅₁₅₃₀	₊₁₇₂₅	_1675162	_1720351	_1444345	_1492620	₁₇₅₀	₃₁₇₀
_{dProofs59.txt}	₇₀₅₃₉	₇₂₈₈₉	₊₂₃₅₀	_2446527	_2502666	_2116170	_2184280	₂₃₉₀	₃₈₇₅
_{dProofs61.txt}	₁₀₀₃₂₃	₁₀₃₉₀₁	₊₃₅₇₈	_3591891	_3691405	_3110013	_3217291	₃₆₄₀	₆₇₄₅
_{dProofs63.txt}	₁₄₂₄₂₀	₁₄₇₄₁₆	₊₄₉₉₆	_5248186	_5375375	_4557440	_4712210	₅₁₀₂	₈₄₅₁
_{dProofs65.txt}	₂₀₂₇₉₄	₂₁₀₃₆₀	₊₇₅₆₆	_7702008	_7922611	_6692202	_6934161	₇₇₁₉	₁₄₂₉₆
_{dProofs67.txt}	₂₈₈₅₃₄	₂₉₉₁₈₃	₊₁₀₆₄₉	_11261412	_11550346	_9810156	_10161303	₁₀₉₁₉	₁₈₅₃₉
_{dProofs69.txt}	₄₁₁₆₅₄	₄₂₇₆₉₄	₊₁₆₀₄₀	_16532019	_17022511	_14407890	_14952832	₁₆₄₅₈	₃₀₆₅₃
_{dProofs71.txt}	₅₈₆₅₄₇	₆₀₉₂₆₄	₊₂₂₇₁₇	_24176669	_24831016	_21115692	_21910141	₂₃₃₆₃	₄₀₄₁₄
_{dProofs73.txt}	₈₃₇₉₈₁	₈₇₂₀₆₅	₊₃₄₀₈₄	_35489102	_36581821	_31005297	_32231334	₃₅₀₇₁	₆₅₆₃₄
_{dProofs75.txt}	_1196203	_1244628	₊₄₈₄₂₅	_51931319	_53412391	_45455714	_47245936	₄₉₉₂₈	₈₇₈₂₇
_{dProofs77.txt}	_1710627	_1782980	₊₇₂₃₅₃	_76223828	_78657948	_66714453	_69461548	₇₄₆₇₂	₁₄₀₆₂₅
_{dProofs79.txt}	_2444582	_2547752	_+103170	_111570583	_114916243	_97783280	_101803368	₁₀₆₇₁₂	₁₉₀₅₂₆
_{dProofs81.txt}	_3499861	_3653261	_+153400	_163784713	_169205301	_143494301	_149624880	₁₅₈₈₂₁	₃₀₁₀₂₇
_{dProofs83.txt}	_5006994	_5226411	_+219417	_239795256	_247330300	_210293748	_219281640	₂₂₇₆₂₂	₄₁₂₀₁₉
Σ_filtered	_16668725	_17373082	_+704357	_755010823	_778386055	_661067944	_688376301	₇₂₈₀₇₈	_1330249

	#₁F	#₂F	ΔF	#₁`C`	#₂`C`	#₁`1`	#₂`1`	#₂`2`	#₂`O`
Σ_filtered	_^16668725	_^17373082	_^+704357	_^755010823	_^778386055	_^661067944	_^688376301	_{⁷²⁸⁰⁷⁸}	_^1330249
_{^{dProofs85-unfiltered85+.txt}}	_^68838412	_^74024284	_^+5185872	_^3447875490	_^3633993208	_^2960051716	_^3177386277	_^5657935	_^9847396
_{^{dProofs87-unfiltered85+.txt}}	_^170845717	_^185049299	_^+14203582	_^8984407350	_^9522321881	_^7517211548	_^8127221988	_^14947168	_^26349695
_{^{dProofs89-unfiltered85+.txt}}	_^335691857	_^364350012	_^+28658155	_^21100407016	_^22388393933	_^15106133565	_^16366042880	_^29707660	_^61263473
_{^{dProofs91-unfiltered85+.txt}}	_^584703462	_^633578953	_^+48875491	_^38592404748	_^40930919963	_^26896359252	_^29093971016	_^50660822	_^109999861
_{^{dProofs93-unfiltered85+.txt}}	_^1060815488	_^1146953429	_^+86137941	_^77867616745	_^82380233788	_^49858327936	_^53817494470	_^89316693	_^216232606
Σ_all	_^2237563661	_^2421329059	_^+183765398	_{^150747722172}	_{^159634248828}	_{^102999151961}	_{^111270492932}	_^191018356	_^425023280

The tables above demonstrate effects of adding COp (the principle of explosion) to CCCpqrCCrpCsp.
For example, by Σ_filtered(ΔF) ∕ Σ_filtered(#₁F) ≈ 4.23% and Σ_all(ΔF) ∕ Σ_all(#₁F) ≈ 8.21%, there are approximately 4.23% more theorems provable in up to 83 steps, but when accounting also for unfiltered files since dProofs85-unfiltered85+.txt, we already have 8.21% more theorems in up to 93 steps.

Calculation	Observation
0.11% ≈ Σ_filtered(#₂`2`) ∕ (Σ_filtered(#₂`1`)+Σ_filtered(#₂`2`)) 0.17% ≈ Σ_filtered(#₂`O`) ∕ (Σ_filtered(#₂`C`)+Σ_filtered(#₂`O`)) 0.17% ≈ Σ_all(#₂`2`) ∕ (Σ_all(#₂`1`)+Σ_all(#₂`2`)) 0.27% ≈ Σ_all(#₂`O`) ∕ (Σ_all(#₂`C`)+Σ_all(#₂`O`))	In minimal proofs of up to 83 steps, only around 0.11% of used axioms are instances of `COp`, while around 0.17% of the operators of their theorems are `⊥`. The proportions go up to 0.17% and 0.27%, respectively, when also including proofs from unfiltered files of up to 93 steps.
45.295 ≈ Σ_filtered(#₁`C`) ∕ Σ_filtered(#₁F) 44.804 ≈ Σ_filtered(#₂`C`) ∕ Σ_filtered(#₂F) 0.0766 ≈ Σ_filtered(#₂`O`) ∕ Σ_filtered(#₂F)	Without `COp`, a theorem minimally proven by up to 83 steps has roughly 45.295 `→` operators on average. With `COp`, such a theorem has roughly 44.804 `→` and 0.0766 `⊥` operators (together ≈44.881) on average.
39.659 ≈ Σ_filtered(#₁`1`) ∕ Σ_filtered(#₁F) 39.623 ≈ Σ_filtered(#₂`1`) ∕ Σ_filtered(#₂F) 0.0419 ≈ Σ_filtered(#₂`2`) ∕ Σ_filtered(#₂F)	On average, there are ≈39.659 axiom references per collected minimal 1-basis proof of up to 83 steps, and ≈39.665 axiom references (≈39.623×`1` and ≈0.0419×`2`) per collected 2-basis proof of up to 83 steps. [Note: Each pure D-proof of length 2k+1 has k+1 axiom references.]
134.24 ≈ Σ_all(#₁F) ∕ Σ_filtered(#₁F) 199.66 ≈ Σ_all(#₁`C`) ∕ Σ_filtered(#₁`C`) 155.81 ≈ Σ_all(#₁`1`) ∕ Σ_filtered(#₁`1`)	For `CCCpqrCCrpCsp`, the five files `dProofs{85,…,93}-unfiltered85+.txt` multiply the total number of theorems, `→` operators, and axiom references by approximate factors of 134.24, 199.66, and 155.81, respectively.
139.37 ≈ Σ_all(#₂F) ∕ Σ_filtered(#₂F) 205.08 ≈ Σ_all(#₂`C`) ∕ Σ_filtered(#₂`C`) 161.64 ≈ Σ_all(#₂`1`) ∕ Σ_filtered(#₂`1`) 319.51 ≈ Σ_all(#₂`O`) ∕ Σ_filtered(#₂`O`) 262.36 ≈ Σ_all(#₂`2`) ∕ Σ_filtered(#₂`2`)	In contrast to the observation above, with `COp` as a second axiom, these files multiply the total number of theorems, `→` operators, and `CCCpqrCCrpCsp`-references by approximately 139.37, 205.08, and 161.64, respectively. The approximate factors for the total number of `⊥` operators and `COp`-references are 319.51 and 262.36, respectively.
5.95 ≈ Σ_filtered(#₂F) ∕ Σ_{dProofs{1,…,73}.txt}(#₂F) 6.78 ≈ Σ_filtered(#₂`C`) ∕ Σ_{dProofs{1,…,73}.txt}(#₂`C`) 6.82 ≈ Σ_filtered(#₂`1`) ∕ Σ_{dProofs{1,…,73}.txt}(#₂`1`) 6.71 ≈ Σ_filtered(#₂`O`) ∕ Σ_{dProofs{1,…,73}.txt}(#₂`O`) 6.60 ≈ Σ_filtered(#₂`2`) ∕ Σ_{dProofs{1,…,73}.txt}(#₂`2`)	To elaborate on the above, the five files `dProofs{75,…,83}.txt` multiply the total number of theorems, `→` operators, `CCCpqrCCrpCsp`-references, `⊥` operators, and `COp`-references only by approximate factors of 5.95, 6.78, 6.82, 6.71, and 6.60, respectively. That the last two are not increased compared to the two before them shows that `⊥` operators and `COp`-references are merely drastically increased in the prior case due to not being filtered out. However, since they are much rarer in total amounts (see first entry), these numbers still show their increasing proportions.

I invite you to draw further interesting connections! Please turn it into a comment or submit a pull request.

The data listed above is insufficient to combine multiple properties of a single entry, e.g. to determine usage distributions of primitives per proof or theorem. The following table shows how many proofs have one or multiple 2-references, and how many 2-referencing proofs derive O-free theorems. These numbers appear alongside #₂F and #₂2 — the numbers of formulas and 2-references (already listed above) — for easier comparison.

_{^{Full table: Σ_filtered}}

	#₂F	#₂`2`	#₂F[#`2`≥1]	#₂F[#`2`≥2]	#₂F[#`2`≥3]	#₂F[#`2`≥1,#`O`=0]
_dProofs1.txt	₂	₁	₁	₀	₀	₀
_dProofs3.txt	₁	₀	₀	₀	₀	₀
_dProofs5.txt	₁	₀	₀	₀	₀	₀
_dProofs7.txt	₃	₀	₀	₀	₀	₀
_dProofs9.txt	₈	₀	₀	₀	₀	₀
_{dProofs11.txt}	₁₅	₁	₁	₀	₀	₀
_{dProofs13.txt}	₂₂	₂	₂	₀	₀	₁
_{dProofs15.txt}	₃₃	₃	₃	₀	₀	₀
_{dProofs17.txt}	₄₅	₄	₄	₀	₀	₀
_{dProofs19.txt}	₆₉	₄	₄	₀	₀	₀
_{dProofs21.txt}	₁₀₁	₄	₄	₀	₀	₀
_{dProofs23.txt}	₁₄₀	₅	₅	₀	₀	₀
_{dProofs25.txt}	₂₀₅	₈	₈	₀	₀	₀
_{dProofs27.txt}	₂₈₀	₁₀	₁₀	₀	₀	₀
_{dProofs29.txt}	₄₀₄	₁₆	₁₆	₀	₀	₀
_{dProofs31.txt}	₅₆₈	₁₇	₁₇	₀	₀	₀
_{dProofs33.txt}	₈₀₉	₂₆	₂₆	₀	₀	₀
_{dProofs35.txt}	₁₁₄₀	₃₄	₃₄	₀	₀	₀
_{dProofs37.txt}	₁₆₁₄	₅₁	₅₁	₀	₀	₀
_{dProofs39.txt}	₂₂₇₈	₆₇	₆₇	₀	₀	₀
_{dProofs41.txt}	₃₂₁₇	₁₀₁	₁₀₁	₀	₀	₀
_{dProofs43.txt}	₄₅₂₉	₁₂₉	₁₂₉	₀	₀	₀
_{dProofs45.txt}	₆₄₂₆	₂₀₃	₂₀₃	₀	₀	₀
_{dProofs47.txt}	₉₀₄₂	₂₆₈	₂₆₈	₀	₀	₀
_{dProofs49.txt}	₁₂₈₂₉	₄₁₈	₄₁₆	₂	₀	₀
_{dProofs51.txt}	₁₈₀₇₆	₅₅₁	₅₄₈	₃	₀	₁
_{dProofs53.txt}	₂₅₆₆₇	₈₄₁	₈₃₉	₂	₀	₁
_{dProofs55.txt}	₃₆₂₂₄	₁₁₄₇	₁₁₄₁	₆	₀	₇
_{dProofs57.txt}	₅₁₅₃₀	₁₇₅₀	₁₇₃₉	₁₁	₀	₁₄
_{dProofs59.txt}	₇₂₈₈₉	₂₃₉₀	₂₃₇₁	₁₉	₀	₂₀
_{dProofs61.txt}	₁₀₃₉₀₁	₃₆₄₀	₃₆₁₀	₃₀	₀	₃₈
_{dProofs63.txt}	₁₄₇₄₁₆	₅₁₀₂	₅₀₅₁	₅₀	₁	₅₄
_{dProofs65.txt}	₂₁₀₃₆₀	₇₇₁₉	₇₆₄₄	₇₄	₁	₈₃
_{dProofs67.txt}	₂₉₉₁₈₃	₁₀₉₁₉	₁₀₇₇₇	₁₄₀	₂	₁₃₆
_{dProofs69.txt}	₄₂₇₆₉₄	₁₆₄₅₈	₁₆₂₄₂	₂₁₄	₂	₂₁₅
_{dProofs71.txt}	₆₀₉₂₆₄	₂₃₃₆₃	₂₃₀₂₃	₃₃₆	₄	₃₁₄
_{dProofs73.txt}	₈₇₂₀₆₅	₃₅₀₇₁	₃₄₅₃₉	₅₂₆	₆	₄₈₂
_{dProofs75.txt}	_1244628	₄₉₉₂₈	₄₉₁₂₉	₇₈₈	₁₁	₇₃₆
_{dProofs77.txt}	_1782980	₇₄₆₇₂	₇₃₄₁₆	₁₂₃₈	₁₈	₁₁₃₀
_{dProofs79.txt}	_2547752	₁₀₆₇₁₂	₁₀₄₈₀₈	₁₈₆₇	₃₇	₁₇₂₅
_{dProofs81.txt}	_3653261	₁₅₈₈₂₁	₁₅₅₈₆₉	₂₈₉₉	₅₃	₂₆₃₂
_{dProofs83.txt}	_5226411	₂₂₇₆₂₂	₂₂₃₁₈₃	₄₃₃₇	₁₀₁	₄₀₂₃
Σ_filtered	_17373082	₇₂₈₀₇₈	₇₁₅₂₉₉	₁₂₅₄₂	₂₃₆	₁₁₆₁₂

	#₂F	#₂`2`	#₂F[#`2`≥1]	#₂F[#`2`≥2]	#₂F[#`2`≥3]	#₂F[#`2`≥1,#`O`=0]
Σ_filtered	_^17373082	_{⁷²⁸⁰⁷⁸}	₇₁₅₂₉₉	₁₂₅₄₂	₂₃₆	₁₁₆₁₂
_{^{dProofs85-unfiltered85+.txt}}	_^74024284	_^5657935	_5528486	₁₂₈₀₅₄	₁₃₈₁	₃₀₅₄₅
_{^{dProofs87-unfiltered85+.txt}}	_^185049299	_^14947168	_14589508	₃₅₃₇₄₇	₃₈₇₇	₇₆₄₂₂
_{^{dProofs89-unfiltered85+.txt}}	_^364350012	_^29707660	_28980041	₇₁₉₂₁₄	₈₃₀₉	₃₇₅₀₈₅
_{^{dProofs91-unfiltered85+.txt}}	_^633578953	_^50660822	_49380674	_1263772	₁₆₁₉₃	₇₇₄₇₂₀
_{^{dProofs93-unfiltered85+.txt}}	_^1146953429	_^89316693	_87112821	_2176502	₂₇₀₂₈	_1338214
Σ_all	_^2421329059	_^191018356	_186306829	_4653831	₅₇₀₂₄	_2606598

I collected the entries that count towards Σ_filtered(#₂F[#2≥2]), Σ_all(#₂F[#2≥3]), and Σ_filtered(#₂F[#2≥1,#O=0]). The corresponding files are linked in their respective cells. They should provide numerous use cases of the principle of explosion and thus contribute to a better understanding. Additional excerpts from extraction-l40l30 have been uploaded to the same location but are also included in the archive of the full extraction.

Calculation	Observation
1.62% ≈ Σ_filtered(#₂F[#`2`≥1,#`O`=0]) ∕ Σ_filtered(#₂F[#`2`≥1]) 1.40% ≈ Σ_all(#₂F[#`2`≥1,#`O`=0]) ∕ Σ_all(#₂F[#`2`≥1])	Only around 1.62% of the minimal `COp`-referencing proofs of up to 83 steps derive a `⊥`-free theorem. The proportion grows even lower when including longer unfiltered proofs.
4.12% ≈ Σ_filtered(#₂F[#`2`≥1]) ∕ Σ_filtered(#₂F) 0.072% ≈ Σ_filtered(#₂F[#`2`≥2]) ∕ Σ_filtered(#₂F) 0.0014% ≈ Σ_filtered(#₂F[#`2`≥3]) ∕ Σ_filtered(#₂F) 7.69% ≈ Σ_all(#₂F[#`2`≥1]) ∕ Σ_all(#₂F) 0.192% ≈ Σ_all(#₂F[#`2`≥2]) ∕ Σ_all(#₂F) 0.0024% ≈ Σ_all(#₂F[#`2`≥3]) ∕ Σ_all(#₂F)	Approximate proportions of minimal proofs of up to 83 steps that reference the principle of explosion at least once, twice, and thrice are 4.12%, 0.072%, and 0.0014% (less than 1 in 73614), respectively. The proportions grow to 7.69%, 0.192%, and 0.0024% (less than 1 in 42461) when also including `dProofs{85,…,93}-unfiltered85+.txt` .

Remarks

About the `CCCpqrCCrpCsp,COp`-proofs of A3_C-O:`CCCpOCqOCqp`

Just like your 319-step proof, my 155-step proof also derives CCCpqCrOCrp [i.e. merco1lem3:((p→q)→(r→⊥))→(r→p)], which is a schema of A3_C-O:((p→⊥)→(q→⊥))→(q→p). But your final step is

CCCpqCrOCrp = D<CCpCqrCCCrsCqpCqr>2 = D<(p→(q→r))→(((r→s)→(q→p))→(q→r))><⊥→p>

i.e.

$ pmGenerator -c -n -s CCCpqrCCrpCsp,COp --parse DDDDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D1111111DDDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDD1DDDD1D1D1D1DDDD1D1D1DDD1D1111111111D1DDD1D1DDD1D1111111DDDD1D1D1DDD1D111111111DDD1DDDD1D1D1D1DDDD1D1D1DDD1D1111111111D1DDDDDD1D1D1D1DDDD1D1D1DDD1D1111111111DDDD1D1D1DDD1D1111111112 -u -j 1
[…]
1. ⊥→(2→0)  (2)
2. (⊥→(2→0))→(((0→1)→(2→⊥))→(2→0))  (R):49
3. ((0→1)→(2→⊥))→(2→0)  (D):1,2

while mine is

CCCpqCrOCrp = D<CpCCCqrCsOCsq>1 = D<p→(((q→r)→(s→⊥))→(s→q))><((p→q)→r)→((r→p)→(s→p))>

i.e.

$ pmGenerator -c -n -s CCCpqrCCrpCsp,COp --parse DDD1DDDDDD1D1D1D1DDDD1D1D1111111111DDDDDD1D1D1D1DDDD1D1D111111111DDDD1DDDD1DDD1D1D1D1D1DDDD1D1D111111111DDD1DDD1DDD1D1D1DDDD1D1D1111111D1D1DDD1D11111111121 -u -j 1
[…]
1. ((3→4)→5)→((5→3)→(6→3))  (1)
2. (((3→4)→5)→((5→3)→(6→3)))→(((0→1)→(2→⊥))→(2→0))  (R):40
3. ((0→1)→(2→⊥))→(2→0)  (D):1,2

Graph Images

I generated scatter plots with the RapidTables tool — press "Zoom In" nine times to match dimensions of my existing behavioral graphs. The tool processed data like 1 0 2 0 3 0 4 0 5 0 6 0 7 0 8 0 9 1 10 0 11 5 […], generated by --plot -s -x <n>. I additionally used SVG compression tools (1. Compress-Or-Die, 2. Vecta) to beautify the output, then replaced all >< by >\n< (where \n is the newline character). In order to not deal with layouts again, I then copied the grid and <circle […]/> entries over their counterparts in copies of already finished vector graphics.

Vertical lines (illustrating averages and medians) were adjusted by modifying the relevant x-coordinates in their <path […]/> entries after obtaining target values from drawing single-dot entries (e.g. 77 0 for median 77) with the RapidTables tool.

Collecting Data for Comparison

I obtained data for the first two tables via shell scripts like

for i in {1..83..2}; do
  tr -cd 'C' < dProofs${i}.txt | wc -m
done
for i in {85..93..2}; do
  tr -cd 'C' < dProofs${i}-unfiltered85+.txt | wc -m
done

which I used in dProofs-withConclusions (for 'C' and 'O') and dProofs-withoutConclusions (for '1' and '2').
I first had to use ./pmGenerator -c -n -s CCCpqrCCrpCsp --variate 0 and ./pmGenerator -c -n -s CCCpqrCCrpCsp,COp --variate 0 to create the proof files with removed conclusions.

To obtain the more intricate numbers of #₂F[#2≥1], #₂F[#2≥2], #₂F[#2≥3], and #₂F[#2≥1,#O=0], I used regular expressions ^[^:]*2[^:]*:.*$, ^[^:]*2[^:]*2[^:]*:.*$, ^[^:]*2[^:]*2[^:]*2[^:]*:.*$, and ^[^:]*2[^:]*:[^O]*$, respectively, in shell code like

count=0
while IFS= read -r line || [ -n "$line" ]; do
    if [[ "$line" =~ ^[^:]*2[^:]*:[^O]*$ ]]; then
        ((count++))
        # In case of collecting entries
        echo "$line" >> "$LOG_FILE"
    fi
done < "$file"
echo "$(basename "$file"): $count"
total_sum=$((total_sum + count))

but it turned out very slow. An optimized compiled language can probably do these things tens if not hundreds of times faster.

Thanks to Notepad++'s excellent editing capabilities (e.g. Alt + Left Mouse drag or Ctrl + Left Mouse click to edit or copy many places at once) and some online tools (Quick Sum Calculator, Equation Solver, and Merge lists), I could quickly assemble the massive Markdown tables from raw data. To remove columns at the front or back, I used regex replacements with expressions like (?<=\n)\|([^\|]+\|){2} and \n\|([^\|]+\|){2}\K[^\n]+(?=\n).

Time Calculations

Each log file has a manually added header where I noted wall-clock time in hours and computing costs in core-hours. I copy timestamps from the log files and paste them like May 20 04:37:24 2026 - May 26 09:21:33 2026 to Wolfram|Alpha in order to produce the number of seconds as an output, e.g. 535449 seconds. The documented numbers are based on this number, e.g. 535449 ∕ 3600 = 148.7358333… h wall-clock time, which makes 148.7358333… * 96 = 14278.64 core-h in case 96 total cores were used. Sometimes Slurm reports durations in D⁺‑H⁺:M⁺:S⁺ format (e.g. in email notifications), which I quickly convert to hours with my custom duration converter.

Large & Additional Files

I did not recompress and upload the exhaustively generated unfiltered85+ files since they are of little use on machines with more regular consumer-sized RAM, whereas on machines with 2 TiB of RAM they can quickly be regenerated from …,dProofs83.txt. Much of their value was also extracted into the partial generations. I may still upload them (or larger extractions thereof) upon request.

7-Zip & Memory Issues

I usually repack files on Windows in order to make use of the better compression options of the 7-Zip GUI application for Windows. When I repacked CCCpqrCCrpCsp,COp's exhaustively generated dProofs83.txt (1 187 918 763 bytes) for the first time on a local machine using 7-Zip, it resulted in an archive with a single . character replaced by a /. I suppose it was due to malfunctioning non-ECC RAM (this particular PC met the blue screen of death several times recently), which shouldn't happen on the cluster machines due to ECC.

_^Details

Original file, line 4500578

DD1DDD1D1DDD1D111111D1D1DDDDD1D1D11111D1D1DD1D1D1D1DDDDD1D1D11111D1D1DD1DD11D1D1111:C0CCC1C2CCC3.4CCC5C6CCC7.8CCCC9.10C10.10.10C11.10C12CCCC9.10C10.10.10C11.10.13C14.13C15CCC5C6CCC7.8CCCC9.10C10.10.10C11.10C12CCCC9.10C10.10.10C11.10.13C14.13C16.17C16.17

Corrupted file, same line

DD1DDD1D1DDD1D111111D1D1DDDDD1D1D11111D1D1DD1D1D1D1DDDDD1D1D11111D1D1DD1DD11D1D1111:C0CCC1C2CCC3.4CCC5C6CCC7.8CCCC9.10C10.10.10C11.10C12CCCC9.10C10.10.10C11.10.13C14.13C15CCC5C6CCC7.8CCCC9.10C10.10/10C11.10C12CCCC9.10C10.10.10C11.10.13C14.13C16.17C16.17

Query to quickly^✻ print this entry:

pmGenerator -c -n -s CCCpqrCCrpCsp,COp --search DD1DDD1D1DDD1D111111D1D1DDDDD1D1D11111D1D1DD1D1D1D1DDDDD1D1D11111D1D1DD1DD11D1D1111 -p

^✻_{Assuming the hard disk is fast; e.g., it takes close to 2 seconds on my SSD (Samsung 870 EVO).}

This is the first time I noticed that such an error occurred when I compressed a file, but I find it worth mentioning that it can happen. So it is important to verify in the end that the compressed files match the originals. In this case, comparing the CRC hash values within 7-Zip on Windows would have revealed the error, since they changed from EA336972 (result from server) to 3D44B005.

But I was a little hasty and only realized that something was wrong when pmGenerator -c -n -s CCCpqrCCrpCsp,COp --plot -s -x 400 (the command to collect data for the behavioral graph) counted a theorem of even symbolic length (which C-O formulas cannot form).

I double-checked all the other recompressed files afterwards.

Making sure two archives (with many files) are equal

"D:/Program Files/7-Zip/7z" l -slt <archive1>.7z > slt1.txt
"D:/Program Files/7-Zip/7z" l -slt <archive2>.7z > slt2.txt
diff slt1.txt slt2.txt | grep CRC
- Should have empty output.
  - Two equal CRCs listed? Sometimes the files listed in slt1.txt and slt2.txt must be rearranged to the same order via editing.
diff slt1.txt slt2.txt | grep Path
- Should only print paths of the two compared .7z archives.

0 replies

Uh oh!

[1-basis C] [2-basis C-O] Question about the ideal minimization process #13

Uh oh!

GinoGiotto May 19, 2026

Soapbox thoughts

Replies: 3 comments · 2 replies

Uh oh!

Uh oh!

xamidi May 20, 2026 Maintainer

Uh oh!

Uh oh!

xamidi May 26, 2026 Maintainer

Update

Uh oh!

Uh oh!

GinoGiotto May 27, 2026 Author

Uh oh!

Uh oh!

xamidi May 27, 2026 Maintainer

Uh oh!

xamidi Jun 19, 2026 Maintainer

1. Groundwork

2. Takeoff

3. Ascent

Initial Results

CCCpqrCCrpCsp

Extracted & Partially Generated

Exemplary Proofs

Concrete D-proofs / “Proof List”

Abstract Representation / “Proof Summary”

CCCpqrCCrpCsp,COp

Extracted & Partially Generated

Exemplary Proofs

Concrete D-proofs / “Proof List”

Abstract Representation / “Proof Summary”

Comparison: CCCpqrCCrpCsp vs. CCCpqrCCrpCsp,COp

Remarks

About the CCCpqrCCrpCsp,COp-proofs of A3C-O:CCCpOCqOCqp

Graph Images

Collecting Data for Comparison

Time Calculations

Large & Additional Files

7-Zip & Memory Issues

Making sure two archives (with many files) are equal

GinoGiotto
May 19, 2026

Replies: 3 comments 2 replies

xamidi
May 20, 2026
Maintainer

xamidi May 26, 2026
Maintainer

GinoGiotto
May 27, 2026
Author

xamidi May 27, 2026
Maintainer

xamidi
Jun 19, 2026
Maintainer

`CCCpqrCCrpCsp`

`CCCpqrCCrpCsp,COp`

Comparison: `CCCpqrCCrpCsp` vs. `CCCpqrCCrpCsp,COp`

About the `CCCpqrCCrpCsp,COp`-proofs of A3_C-O:`CCCpOCqOCqp`