True Prime Pairs
This is the partial of the mapping scheme of our eQuantum Project. Our mapping is simulating a recombination of the three (3) layers of these prime pairs.
This section is referring to wiki page2 of zone section2 that is inherited from the zone section2 by prime spin2 and span with the partitions as below.
/grammar
An Independent claim is also included for the localization and determination, or their material structures, by graphical representation of base sequences on various media, based on the new assignments and the derived vibrations and amplitudes.
Prime Objects
In short this project is mapping the quantum way within a huge of prime objects (5 to 19) by lexering (11) the ungrammared feed (7) and parsering (13) across syntax (17).
5, 2, 1, 0
7, 3, 1, 0
11, 4, 1, 0
13, 5, 1, 0
17, 0, 1, 1
19, 1, 1, 1
The 5+7+11+13 is the smallest square number expressible as the sum of four consecutive primes which are also two couples of prime twins!
 Their sum is 36 which is the smallest square that is the sum of a twin prime pair {17, 19}.
 This 36 is the smallest number expressible as the sum of consecutive prime in two (2) ways (5+7+11+13 and 17+19).
This export/import process is specific to each frontend and typically involves a number of stages which can then be "imported" into IREE.
IREE (Intermediate Representation Execution Environment1) is an MLIRbased endtoend compiler and runtime that lowers Machine Learning (ML) models to a unified IR that scales up to meet the needs of the datacenter and down to satisfy the constraints and special considerations of mobile and edge deployments.
$True Prime Pairs:
(5,7), (11,13), (17,19)
layer i  f
++
 1  5
1 ++
 2  7
++ } 36 » 6®
 3  11
2 ++
 4  13
++
 5  17
3 ++ } 36 » 6®
 6  19
++
IREE supports most popular machine learning frameworks using the same underlying technology. Here we are going to use SavedModels from TensorFlow Hub.
Each machine learning framework has some “export” mechanism that snapshots the structure and data in your program.
 Capture/trace/freeze the ML model into a graph
 Write that graph to an interchange format (e.g. SavedModel, TorchScript, ONNX)
 Load the saved program into an import tool and convert to MLIR
 Legalize the graph’s operations so only IREEcompatible operations remain
 Write the imported MLIR to a file
This fully imported form can then be compiled indepedently of the source languages and framework. See the samples directory.
Using this trained machine learning models we shall do finetuning and make it deployable to discuss the undiscovered features as we have discussed before.
These files can be imported into an IREEcompatible format then compiled to a series of backends.
 TensorFlow programs represented as tf.Module classes or stored in the SavedModel format.
 TensorFlow Lite (TFLite) programs stored as TFLite FlatBuffers.
See the deployment configuration guides for details on selecting a compiler backend and tuning options for your choice of target platform(s) or device(s).
$True Prime Pairs:
(5,7), (11,13), (17,19)
layer  node  sub  i  f
+++
   1 
  1 ++
 1   2  (5)
 ++
   3 
1 ++ 2 ++
   4 
 +++
 2   5  (7)
  3 ++
   6 
++++ } (36)
   7 
  4 ++
 3   8  (11)
 +++
   9 
2 + 5 ++
   10 
 ++
 4   11  (13)
  6 ++
   12 
++++
   13 
  7 ++
 5   14  (17)
 ++
   15 
3 ++ 8 ++ } (36)
   16 
 ++
 6   17  (19)
  9 ++
   18 
++
TensorFlow Quantum (TFQ) is designed for the problems of NISQera quantum machine learning. It brings quantum computing primitives—like building quantum circuits—to the TensorFlow ecosystem.
TensorFlow Quantum implements the components needed to integrate TensorFlow with quantum computing hardware. To that end, TFQ introduces two datatype primitives:
 Quantum circuit: This represents Cirqdefined quantum circuits (cirq.Circuit) within TensorFlow. Create batches of circuits of varying size, similar to batches of different realvalued datapoints.
 Pauli sum: Represent linear combinations of tensor products of Pauli operators defined in Cirq (cirq.PauliSum). Like circuits, create batches of operators of varying size.
Using the quantum circuit primitives within a tf.Tensor, TensorFlow Quantum implements ops that process these circuits and produce meaningful outputs.
TensorFlow Quantum layers expose sampling, expectation, and state calculation to developers using the tf.keras.layers.Layer interface.
It’s convenient to create a circuit layer for classical control parameters or for readout operations. Additionally, you can create a layer with a high degree of complexity supporting batch circuit, batch control parameter value, and perform batch readout operations. See tfq.layers.Sample for an example.
$True Prime Pairs:
(5,7), (11,13), (17,19)
layer  node  sub  i  f
+++
   1  
  1 ++ 
 1   2  (5) 
 ++ 
   3  
1 ++ 2 ++ 
   4  
 +++ 
 2   5  (7) 
  3 ++ 
   6  11s
++++ } (36) 
   7  
  4 ++ 
 3   8  (11) 
 +++ 
   9  
2 + 5 ++ 
   10  
 ++ 
 4   11  (13) 
  6 ++ < strip √
   12 
++++ 
   13  
  7 ++ 
 5   14  (17) 
 ++ 
   15  7s = f(1000)
3 ++ 8 ++ } (36) 
   16  
 ++ 
 6   17  (19) 
  9 ++ 
   18  
++#
Unlike many TensorFlow operations, observables in quantum circuits do not have formulas for gradients that are relatively easy to calculate.
We consider a certain theory of 3forms in 7 dimensions, and study its dimensional reduction to 4D, compactifying the 7dimensional manifold on the 3sphere of a fixed radius.
 We show that the resulting 4D theory is (Riemannian) General Relativity (GR) in Plebanski formulation, modulo corrections that are negligible for curvatures smaller than Planckian.
 Possibly the most interesting point of this construction is that the dimensionally reduced theory is GR with a nonzero cosmological constant, and the value of the cosmological constant is directly related to the size of . Realistic values of Λ correspond to of Planck size.
In our approach a 3form is not an object that exist in addition to the metric, it is the only object that exist. The metric, and in particular the 4D metric, is defined by the 3form. (General relativity from threeforms in seven dimensions  pdf)
The tfq.datasets module is used as the data source for quantum machine learning tasks. It ensures structured comparisons for the model and performance.
In this article we will support this conjecture and develop a new approach to quantum gravity called smooth quantum gravity by using smooth 4manifolds with an exotic smoothness structure.
 In particular we discuss the appearance of a wildly embedded 3manifold which we identify with a quantum state.
 Furthermore, we analyze this quantum state by using foliation theory and relate it to an element in an operator algebra.
 Then we describe a set of geometric, noncommutative operators, the skein algebra, which can be used to determine the geometry of a 3manifold.
 This operator algebra can be understood as a deformation quantization of the classical Poisson algebra of observables given by holonomies.
 The structure of this operator algebra induces an action by using the quantized calculus of Connes.
The scaling behavior of this action is analyzed to obtain the classical theory of General Relativity (GRT) for large scales. (Smooth quantum gravity  pdf)
The TensorFlow ops are written in optimized C++. These ops sample from circuits, calculate expectation values, and output the state produced by the given circuits.
Construction of a State
$True Prime Pairs:
(5,7), (11,13), (17,19)
layer  node  sub  i  f
+++ < Mobius strip √
   1  
  1 ++ 
 1   2  (5) 
 ++ 
   3  
1 ++ 2 ++ 
   4  
 +++ 
 2   5  (7) 
  3 ++ 
   6  11s
++++ } (36) 
   7  
  4 ++ 
 3   8  (11) 
 +++ 
   9  
2 + 5 ++ 
   10  
 ++ 
 4   11  (13) 
  6 ++ < Mobius strip
   12 
++++ 
   13  
  7 ++ 
 5   14  (17) 
 ++ 
   15  7s = f(1000)
3 ++ 8 ++ } (36) 
   16  
 ++ 
 6   17  (19) 
  9 ++ 
   18  
++ < Möbius strip √
The funny looking Möbius strip, which was also independently discovered in 1858 by the unlucky Listing whose name left the history of mathematics untouched.
 It is a surface with only one side and only one boundary, often used to puzzle young math students. You can easily create it by taking a strip of paper, twisting it and then joining the ends of the strip.

Being the first example of a surface without orientation it did not shake the grounds of mathematics as much as the other discoveries of this list did, yet it provided a lot of practical applications, such as a resistant belt, and inspired mathematicians to come up with unorientable surfaces, like the Klein bottle.
 The name of this surface possibly comes from a double coincidence: Klein, its conceptor, originally named it Fläche, which means surface in German and sounds similar to Flasche, which means bottle. The fact that it also looked like a bottle seems to have sealed the renaming.
Mathematical fields were created, we got the Turing Machine, fancy looking surfaces and, most importantly, the ability to reexamine our perceptions and adapt our tools accordingly. (freeCodeCamp)
These items are elementary parts possessing familiar properties but they never exist as free particles. Instead they join together by the strong force into bound states.
f(18) = f(7) + f(11) = (1+7+29) + 11th prime = 37 + 31 = 36 + 32 = 68
The holonomy tells you how to propagate MEC30. A spin network state assigns an amplitude to a set of spin half particles tracing out a path in space, merging and splitting.
This kind of approach has some obvious properties: there are nonlinear gravitons, a connection to lattice gauge field theory and a dimensional reduction from 4D to 2D.
Bilateral 9 Sums
Eigennvalue curves (right) showing a triple eigenvalue at zero for τ = 1 and double eigenvalues at 1 ± √2i for τ = √43. On the left the graph of 1/Q(λ) with the same eigenvalue curves plotted in the ground plane. Green stars indicate the eigenvalues of A, blue stars the roots of puv(λ) and triangles the zeroes of Q0(λ)
10 + 10th prime + 10th prime = 10 + 29 + 29 = 68
$True Prime Pairs:
(5,7), (11,13), (17,19)
layer  node  sub  i  f
+++ < Mobius strip
   1  
  1 ++ 
 1   2  (5) 
 ++ 
   3  
1 ++ 2 ++ 
   4  
 +++ 
 2   5  (7) 
  3 ++ 
   6  11s ‹ (71) √
++++ } (36) 
   7  
  4 ++ 
 3   8  (11) 
 +++ 
   9  
2 + 5 ++ 
   10  
 ++ 
 4   11  (13) 
  6 ++ < Mobius strip
   12 
++++ 
   13  
  7 ++ 
 5   14  (17) 
 ++ 
   15  7s ‹ (43) √
3 ++ 8 ++ } (36) 
   16  
 ++ 
 6   17  (19) 
  9 ++ 
   18  
++ < Möbius strip
This pattern is raised up per six (6) cycles on the 19, 43 and 71. Since the members are limited to the sum of 43+71=114.
So here the bilateral way of 19 that originated by the (Δ1) is clearly the one that controls the scheme.
In the matrix pictured below, we list the first 24 elements of our domain, take their squares, calculate the modulo 90 congruence and digital roots of each square, and display the digital root factorization dyad for each square (and map their collective bilateral 9 sum symmetry). (PrimesDemystified)
7 x π(89) = 7 x 24 = 168 = π(1000)
Supersymmetric Multiplet
$True Prime Pairs:
(5,7), (11,13), (17,19)
layer  node  sub  i  f. MEC 30 / 2
++++ ‹ 0 {1/2}
   1  
  1 ++ 
 1   2  (5) 
 ++ 
   3  
1 ++ 2 ++ 
   4  
 +++ 
 2   5  (7) 
  3 ++ 
   6  11s ‹ ∆28 = (7143) √
++++ } (36) 
   7  
  4 ++ 
 3   8  (11) 
 +++ 
   9 ‹ ∆9 = (8971) / 2 √ 
2 + 5* ++ 
   10  
 ++ 
 4   11  (13) 
  6 ++ ‹ 15 {0}
   12 
++++ 
   13  
  7 ++ 
 5   14  (17) 
 ++ 
   15  7s ‹ ∆24 = (4319) √
3* ++ 8 ++ } (36) 
   16  
 ++ 
 6   17  (19) 
  9 ++ 
   18  
++ ‹ 30 {+1/2}
Given our domain is limited to numbers ≌ {1,7,11,13,17,19,23,29} modulo 30, only ϕ(m)/m = 8/30 or 26.66% of natural numbers N = {0, 1, 2, 3, …} need be sieved.
 For example, to illustrate the proportionality of this ratio, we find that 25% of the first 100 natural numbers are prime, while 72% of numbers not divisible by 2, 3, or 5 are prime (and, curiously, if we count 2, 3, and 5 in after the fact, we get 75%, or exactly 3 x 25%).
 Also note that if you plug the number 30 into Euler’s totient function, phi(n): phi(30)= 8, with the 8 integers (known as totatives) smaller than and having no factors in common with 30 being: 1, 7, 11, 13, 17, 19, 23 and 29, i.e., what are called “prime roots” above. Thirty is the largest integer with this property.]
 The integer 30, product of the first three prime numbers (2, 3 and 5), and thus a primorial, plays a powerful role organizing the array’s perfect symmetry, viz., in the case of the 8 prime roots:
1+29=30; 7+23=30; 11+19=30; and 13+17=30.
 In The Number Mysteries wellknown mathematician Marcus Du Sautoy writes: “In the world of mathematics, the numbers 2, 3, and 5 are like hydrogen, helium, and lithium. That’s what makes them the most important numbers in mathematics.”
 Although 2, 3 and 5 are the only prime numbers not included in the domain under discussion, they are nonetheless integral to it: First of all, they sieve out roughly 73% of all natural numbers, leaving only those nominally necessary to construct a geometry within which prime numbers can be optimally arrayed.
 The remaining 26.66% (to be a bit more precise) constituting the array can be constructed with an elegantly simple interchangeable expression (or power series, if you prefer) that incorporates the first three primes. It’s conjectured that this manifold series ultimately consists of all (and only) the numbers not divisible by 2, 3, or 5 (and their negatives), which inclues all prime numbers >5 (more below under the heading “Conjectures and Facts Relating to the Prime Spiral Sieve”).
What is critical to understand, is that the invisible hand of 2, 3 and 5, and their factorial 30, create the structure within which the balance of the prime numbers, i.e., all those greater than 5, are arrayed algorithmically–as we shall demonstrate. Primes 2, 3 and 5 play out in modulo 306090 cycles (decomposing to {3,6,9} sequencing at the digital root level). Once the role of 2, 3 and 5 is properly understood, all else falls beautifully into place. (PrimesDemystified)
Moreover it can generate an online documentation browser (in HTML) and/or an offline reference manual (in LaTeX) from a set of documented source files.
Many scientific communities have adopted communitybased models that integrate multiple components to simulate whole system dynamics.
 The community software projects’ complexity, stems from the integration of multiple individual software components that were developed under different application requirements and various machine architectures, has become a challenge for effective software system understanding and continuous software development.
 The paper presents an integrated software toolkit called Xray Software Scanner (in abbreviation, XScan) for a better understanding of largescale communitybased scientific codes.
 Our software tool provides support to quickly summarize the overall information of scientific codes, including the number of lines of code, programming languages, external library dependencies, as well as architecturedependent parallel software features.
 The XScan toolkit also realizes a static software analysis component to collect detailed structural information and provides an interactive visualization and analysis of the functions.
We use a largescale communitybased Earth System Model to demonstrate the workflow, functions and visualization of the toolkit. We also discuss the application of advanced graph analytics techniques to assist software modular design and component refactoring. (XScan  pdf)
Then, we will apply machine learning approaches to aid users in optimizing software structure and functional redesigns.