# Proofreading Ability

``````---+-----+-----
1 | {1} |{56}
---+-----+-----
2 | 57  |{71}
---+-----+-----
3 | 72  | 85
---+-----+-----
4 |{86} |{89}
---+-----+-----
5 | 90  | 94
---+-----+-----
6 | 95  | 102
---+-----+-----
7 | 103 |{171}
---+-----+-----
8 | 172 | 206
---+-----+-----
``````
``````True Prime Pairs:
(5,7), (11,13), (17,19)

layer|  i  |   f
-----+-----+---------
|  1  |   5
1  +-----+
|  2  |  {7}
-----+-----+---    } 36
|  3  |  11
{2} +-----+
|  4  | {13}
-----+-----+---------
|  5  |  17
3  +-----+       } 36
|  6  | {19}
-----+-----+---------
``````

## Infinite connection

``````Φ = 2,10
Δ = 5,7,17
3': 13,18,25,42
2' » 13 to 77, Δ = 64
2' and 3' » 13 to 45, Δ = 32

2" + 5" = 7" = 77
2"=22, 3"=33, 2" + 3" = 5" = 55

13, 16, 18, 21, 23, 25, 28, 30, 32, 34,
36, 38, 40, 42,
45, 47, 49, 51, 53,
55, 57, 59, 61,
63, 65, 67, 69, 71, 73, 75, 77
``````

Next we will discuss how to form these numbers on each screens. As explained earlier, there are all three (3) layers. The instance is going to simulate DNA polymerase with proofreading ability.

Proofreading removes the mismatched nucleotide and extension continues. If a mismatch is accidentally incorporated, the polymerase is inhibited from further extension (Wikipedia).

A current model of meiotic recombination, initiated by a double-strand break or gap, followed by pairing with an homologous chromosome and strand invasion to initiate the recombinational repair process (Wikipedia).

π(96) = 96/4 = 24

Fidelity is very important in DNA replication. Mismatches in DNA base pairing can potentially result in dysfunctional proteins and could lead to cancer. Hydrogen bonds play a key role in base pair binding and interaction.

The function of DNA polymerase is not quite perfect, with the enzyme making about one mistake for every billion base pairs copied. Error correction is a property of some, but not all DNA polymerases. This process corrects mistakes in newly synthesized DNA (Wikipedia).

### Strand Partition

``````layer | node | sub |    i     |   f
------+------+-----+----------+-----+-----+-----+                                    ---
|      |     |    1,2:1 |   1 |  30 |  40 | 71 (2,3) ‹-------------------       |
|      |  1  +----------+-----+-----+-----+                              |      |
|  1   |     |        2 |                                                |      5¨  encapsulation
|      |-----+----------+            -----------------------------       |      |
|      |     |        3 |           |                             |      |      |
1   +------+  2  +----------+----       |       LAGGING SCHEME        |      |     ---
|      |     |        4 |           |    (Exponentiation Zone)    |      |      |
|      +-----+----------+           |                             |      |      |
|  2   |     |        5 |           ------------------------------       |      7¨  abstraction
289   |      |  3  +----------+                                                |      |
|     |      |     |        6 |  ‹---------------------------- Φ               | {6®} |
------+------+-----+----------+-----+-----                                     |     ---
|      |     |     11:7 |   5 |   9 |  14 (20) --------› ¤               |      |
|      |  4  +----------+-----+-----+-----+                              |      |
|  3   |     |     12:8 |   9 |  60 |  40 | 109 (26) «------------       |     11¨  polymorphism
|      +-----+----------+-----+-----+-----+                       |      |      |
|      |     |     13:9 |   9 |  60 |  69 (27) «-- Δ19 (Rep Fork) | {2®} |      |
2   +------|  5  +----------+-----+-----+-----+                       |      |     ---
|      |     |    14:19 |   9 |  60 |  40 | 109 (28) -------------       |      |
|      |-----+----------+-----+-----+-----+                              |      |
|  4   |     | 15,18:11 |   1 |  30 |  40 | 71 (29,30,31,32) ------------      13¨  inheritance
329   |      |  6  +----------+-----+-----+-----+                                     |
|     |      |     |    19:12 |  10 |  60 | {70} (36) -------› Φ                      |
------+------+-----+----------+-----+-----+                                          ---
|      |     |    20:13 |  90 |  90 (38) ‹-------------- ¤                      |
|      |  7  +----------+-----+                                                 |
|  5   |     |       14 |            -----------------------------             17¨  class
|      |-----+----------+           |                             |             |
|      |     |       15 |           |       LEADING SCHEME        |             |
3   +------+  8  +----------+-----      |    (Multiplication Zone)    |            ---
|      |     |       16 |           |                             |             |
|      |-----+----------+-----+      -----------------------------              |
|  6   |     |    28:17 | 100 |                                                19¨  object
168   |      |  9  +----------+-----+                                                 |
|     |      |     |    29:18 | 50  | 50(68) ---------> Δ18                           |
------|------|-----+----------+-----+                                                ---
``````

## Four-vector configuration

If you are using Docker-for-Windows, you can run now both Windows and Linux containers simultaneously: Running Docker Windows and Linux Containers Simultaneously, not only the Linux container itself, but also an orchestrator like Kubernetes: Kubernetes is Now Available In Docker Desktop Stable Channel

On the lagging strand template, a primase "reads" the template DNA and initiates synthesis of a short complementary RNA primer. This is assigned to Windows container.

The leading strand is the strand of new DNA which is synthesized in the same direction as the growing replication fork. This sort of DNA replication is continuous. This workflow is assigned to Linux container (Ubuntu).

The runner is the application that runs a job from a GitHub Actions workflow. It is used by GitHub Actions in the hosted virtual environments, or you can self-host the runner in your own environment. We use both of them to create group as a four-vector.

DNA polymerase extends primed segments, forming Okazaki fragments. The RNA primers are then removed and replaced with DNA, and the fragments of DNA are joined by DNA ligase and are bound to the helicase heximer (Wikipedia).

In eukaryotes the helicase wraps around the leading strand, and in prokaryotes it wraps around the lagging strand. As helicase unwinds DNA at the replication fork, the DNA ahead is forced to rotate resulting a build-up of twists in the DNA ahead.

Because of its orientation, replication of the lagging strand is more complicated as compared to that of the leading strand. As a consequence, the DNA polymerase on this strand is seen to "lag behind".

### Hamiltonian Path Problem

By The GitHub Runner you can connect to the Google COS Instance. For self-hosted runners defined at the organization level, configure runs-on.group in your workflow file to target a runner groups or combine groups and labels.

On the other hand, with larger systems we are able to transfer the behavior of the energy from the subatomic space into the haptic space with the scale described here (thought experiment Schröninger's cat). Thus, we are still able to apply the Schröninger wave equation in the haptic space, and replace the Hamiltonian with our measurements.

The problems would arise when the Windows Container in Github deliver the RNA Primer to Google instance as Windows Image because it shall read the image while the COS is run under Linux. So it will need to proof and solve without actually having to try.

If it is easy to check that a solution to a problem is correct, is it also easy to solve the problem? This is the essence of the P vs NP question. Typical of the NP problems is that of the Hamiltonian Path Problem given N cities to visit, how can one do this without visiting a city twice? (Clay Institute).

Getting the proofreading ability of DNA polymerase to quickly solve problem for about one mistake for every billion base pairs copied is somehow that required by one of a major unsolved problem in theoretical computer science called P vs NP.

P vs. NP deals with the gap between computers being able to quickly solve problems vs. just being able to test proposed solutions for correctness. As such, the P vs. NP problem is the search for a way to solve problems that require the trying of millions, billions, or trillions of combinations without actually having to try each one (P vs. NP Explained).

This way will also be our approach to Euler's identity. By taking the correlation between f(π) as P vs f(i) as NP where e + 1 = 0 then theoretically they shall be correlated to get an expression of the prime distribution similar to MEC30.