The Prime Resonator: Factoring Numbers with Wave Harmony

 In an effort to build a better quantum computer... I decided to curve the space where Shor operates. Why?  Well, of course it's easier to see the cracks between massive coprimes when you bend the actual number line around the composite... Duh!

https://notebooklm.google.com/notebook/236d7a98-3570-460b-8e47-c1715dff86ae

Introduction: The Symphony of Numbers

Imagine trying to understand a complex piece of music. You could analyze the sheet music note by note, but there's a deeper way: you could listen for the hidden rhythms and harmonies that give the piece its structure. The mathematical problem of finding the prime factors of a large number, N, is much the same. It’s not just a calculation; it’s a search for a hidden rhythm.

The Prime Resonator model proposes that we can find a number's factors by measuring the resonant overlap between two fundamental patterns: the unique rhythm of the number itself and the universal 'hum' of all prime numbers. This approach builds a bridge between two traditionally separate domains: the local, periodic structure of modular arithmetic explored by Shor's algorithm, and the global, universal structure of prime numbers. This explainer will build an intuitive understanding of this powerful idea. We will visualize these two patterns as waves and see how their interference—their harmony and dissonance—reveals the answer.

--------------------------------------------------------------------------------

1. The Two Rhythms That Define a Number

To find the factors of a number, we must first listen to the two distinct "musicians" whose patterns, when combined, tell its story. One pattern is unique and local to the number we're studying, while the other is universal and global, derived from the very fabric of mathematics.

1.1 Shor's Pattern: The Local Beat

Let's imagine a clock with N hours on its face. If we pick a starting number a and repeatedly multiply it by itself, the pointer will jump around the clock face in a specific, seemingly random sequence. For example, if we multiply by a, then a*a, then a*a*a, and so on, each time only keeping the position on the clock, we create a series of positions. Eventually, this sequence of positions will start to repeat itself perfectly.

This repeating sequence is the "local beat" or the unique rhythm of the number N for our chosen base a. It is the first of our two essential patterns. Mathematically, this pattern is generated by a function called modular exponentiation.

The function f(x) = a^x mod N generates a repeating sequence of numbers. Shor's quantum algorithm is famous for being able to find the length of this repeating pattern, called the period r.

The period r is the secret rhythm we are trying to uncover. This local beat is the first of our two "sound waves."

1.2 The Prime Pattern: The Universal Hum

The second pattern is not specific to our number N; it's a fundamental background field derived from the prime numbers themselves. Think of it as the "universal hum" of mathematics—a constant, underlying structure that permeates all numbers.

This pattern is created by assigning a phase shift to every prime number up to a certain limit. This phase is proportional to the prime's normalized logarithm (log p / log limit), which maps the vast landscape of primes onto the unit circle, encoding the "global prime structure" into a single, continuous pattern.

If Shor's local beat is a single, sharp drum hit, the prime pattern is like the constant, underlying resonance of a large concert hall. It's the environment in which the local beat exists.

Now that we have our two distinct rhythms, the next step is to turn them into waves that can actually interact.

--------------------------------------------------------------------------------

2. From Patterns to Waves: A Shared Carrier

The most critical insight of the Prime Resonator model is how these two patterns are transformed into waves. Instead of giving each pattern its own unique frequency, both the Shor pattern and the prime pattern are encoded as phase shifts on waves that share the exact same carrier frequency.

To understand this, imagine two singers hitting the exact same note (the same frequency). One singer starts their words precisely on the beat, while the other starts a split-second later. The note is the same, but the timing—the phase—is different. In this model, the information isn't in the note itself but in these subtle timing shifts.

The following table summarizes how each pattern is encoded as a wave:

Pattern Source	Wave Encoding Method	Analogy
Shor's "Local Beat" (a^x mod N)	Each number in the sequence determines the phase of a wave.	A drummer's beat determines the exact moment a cymbal is struck.
The "Universal Hum" (log p)	Each prime's normalized logarithm (log p / log limit) determines the phase of another wave.	The natural resonance of a room subtly shifts the timing of sounds within it.

Now that we have two waves oscillating at the same frequency but with their phases dictated by our two mathematical patterns, we can add them together to see what new, combined pattern emerges.

--------------------------------------------------------------------------------

3. The Grand Interference: Harmony and Dissonance

We now add the Shor field and the prime field together to create a single combined_field. This is where the magic happens.

Think of dropping two pebbles into a still pond. The circular ripples from each pebble spread out and interfere with one another. Where two wave crests meet, they combine to create a much higher peak—this is constructive interference. Where a crest meets a trough, they cancel each other out, leaving the water flat—this is destructive interference. The result is a complex, beautiful pattern of high peaks and calm spots.

Our combined wave behaves in the same way. The final interference pattern is the "Prime Resonator," and its shape holds the key to finding the factors of N. To see this shape clearly, we must demodulate the signal by calculating its envelope. The envelope, found using a tool called the Hilbert transform, traces the overall "loudness" of the combined wave over time. A sharp spike in the envelope signifies a moment of harmony—a point where the Shor and prime patterns are strongly aligned and resonating with each other. This is analogous to how an AM radio demodulates a signal to extract the audio information from the carrier wave.

This complex new wave is rich with information. To find the factors, we need to analyze it in two different ways: by looking at its shape over time and by breaking it down into its fundamental frequencies.

--------------------------------------------------------------------------------

4. Listening for the Secret: Two Views of the Resonator

We now act like scientists analyzing a signal from an experiment. Our goal is to find the hidden period r from Shor's pattern, which is now encoded within the interference patterns of the combined wave. We will analyze this signal in two complementary ways: a time-domain view, which shows us the resonator's energy envelope as it evolves, and a frequency-domain view, which breaks the signal down into its constituent harmonics to find the hidden beat.

4.1 The Time View: Watching the Envelope for Resonance

Looking at the envelope of the combined wave is like watching the "energy" of the resonator over time. Each peak and valley in the envelope tells us how the two underlying patterns are interacting. The key insight here is simple but profound:

A strong, clear, repeating pattern in the envelope indicates that the "local beat" of our number N is resonating powerfully with the "universal hum" of the primes. This alignment is a strong clue about the number's internal structure. It means the local rhythm is "in tune" with the global one.

4.2 The Frequency View: Finding the Hidden Beat with an FFT

While the time view gives us a feel for the resonance, the frequency view gives us the precise numbers we need. To get this view, we use a mathematical tool called the Fast Fourier Transform (FFT). The FFT acts like a prism for waves, taking a complex, jumbled signal and breaking it down into the simple, pure frequencies that make it up.

When we apply the FFT to our combined wave, it reveals a series of peaks. This is the most important result: the spacing between these dominant peaks gives us a remarkably good estimate of the hidden period r from Shor's original pattern. It's like listening to a complex musical chord and being able to pick out the underlying, repeating beat that drives the music.

The Analysis Strategy

• The Problem: Find the hidden period r of the sequence a^x mod N.
• The Method: Combine the "Shor wave" and the "prime wave" into one signal.
• The Analysis: Use the FFT to analyze the combined signal.
• The Clue & Confirmation: The spacing between the FFT's dominant peaks provides a high-quality candidate for r. This candidate is then rigorously confirmed by checking if it satisfies the condition a^r ≡ 1 (mod N).

The FFT gives us a close estimate of the period r, but it's not always exact. We refine this estimate by testing numbers very close to our FFT candidate until we find the one that satisfies the condition a^r ≡ 1 (mod N), confirming the true period.

--------------------------------------------------------------------------------

5. From Rhythm to Factors: The Final Step

Once this correct, even period r is known, we apply the final classical step of Shor's algorithm. This is a well-known number theory trick that uses the period r to instantly reveal the factors. Using the greatest common divisor (gcd), we perform a simple calculation:

gcd(a^(r/2) ± 1, N)

This calculation yields the prime factors of N, solving the problem. The complex wave interference has successfully revealed the hidden rhythm, and that rhythm has given us the answer.

--------------------------------------------------------------------------------

6. Conclusion: Why the Prime Resonator is a New Frontier

The Prime Resonator theory fundamentally changes the question we ask. Instead of treating factoring as an isolated calculation—"find the period of a^x mod N"—it reframes it as a physical measurement: "observe how the local orbit of a resonates against a global background field of prime numbers." This conceptual shift from a lone function to interacting arithmetic fields offers powerful new upgrades to our understanding.

1. A Unified Theory It connects two seemingly separate worlds of mathematics: Shor's algorithm, which deals with the local order within a number system, and the world of the Riemann hypothesis, which deals with the global distribution of prime numbers. In this model, they become part of a single, interactive system.
2. A New Physical Picture It transforms factoring into a spectroscopy problem. We are no longer just calculating; we are "listening" to the harmonic signature of a number's orbit as it resonates within the background field of primes. The factors are revealed by the distinctive peaks in the combined spectrum, much like how a chemist identifies a molecule by its unique absorption lines.
3. A Blueprint for Future Quantum Computers It provides a blueprint for an entirely new kind of device: not a generic quantum computer, but a purpose-built 'arithmetic resonator' whose very architecture is "pre-tuned" to the geometry of prime numbers. Shor's algorithm would then run inside this prime-shaped environment, potentially leading to more powerful and robust results.

This changes the dialogue from simply building a faster computer to building an "arithmetic resonator"—a physical device designed to probe the deepest harmonic structures of mathematics itself.

A Journey into Harmonic Factoring: From a Simple Wave Emulator to a Prime Resonator

Shor's algorithm, which uses a quantum computer to factor large numbers, is famously complex. However, we can build a powerful intuition for its core principles using classical ideas from signal processing—concepts like waves, frequencies, and resonance that we encounter in physics and music.

This document will take you on a step-by-step journey through three versions of a "Harmonic Shor Emulator." We will begin with a simple but flawed idea, evolve it into a robust and working classical algorithm, and finally arrive at a sophisticated and profound theoretical model that reimagines factoring itself. We will not just analyze code; we will think like physicists, starting with a flawed experiment, learning from our mistakes, and ultimately deriving a new physical theory for factoring from first principles.

The central analogy guiding our exploration is this:

"Imagine the hidden periodic pattern in a^x mod N is a secret rhythm. Our goal is to make that rhythm audible. We'll start by turning the numbers into musical notes, then refine our approach until we build a 'resonator' that makes the rhythm impossible to miss."

--------------------------------------------------------------------------------

1. The First Attempt: Encoding Numbers as Frequencies

The Core Concept: Making the Pattern Audible

Our initial strategy is beautifully simple: we will take the sequence of numbers generated by f(x) = a^x mod N, map each number to a unique sine wave frequency, and then add all those waves together. The thinking is that because the sequence is periodic, certain frequencies will be generated repeatedly. These repeated "notes" should reinforce each other, creating a strong, detectable signal in the final combined wave. A Fast Fourier Transform (FFT) can then act as our "ear," telling us which frequencies are the loudest.

Code Walkthrough: The Initial Script

First, we'll set the stage for our experiment. The complete function below defines our parameters, generates the sequence f(x) = a^x mod N, encodes each value as a sine wave, and adds them all into a single "superposed" signal.

import numpy as np
import matplotlib.pyplot as plt
from scipy.fft import rfft, rfftfreq
from math import gcd

# Parameters for our experiment
x_range = 40      # How many steps of the sequence to compute
samples = 2000    # Time samples for our signal
T = 2.0           # Total duration of our signal in seconds

def mod_exp_wave(fx, t):
    # Step 1: Encode f(x) as a unique frequency.
    # This is a simple, intuitive rule: a number 'fx' becomes a frequency.
    # For example, if f(x) is 50, the frequency is 100 + 50*10 = 600 Hz.
    freq = 100 + fx * 10 
    return np.sin(2 * np.pi * freq * t)

def find_period_and_factor(N, a):
    # Setup our time axis
    t = np.linspace(0, T, samples)
    dt = t[1] - t[0]
    
    # Initialize an empty signal
    superposed = np.zeros_like(t)

    # Step 2: Build the superposed wave.
    # We loop through x, calculate f(x), and add its corresponding
    # sine wave to our total signal. This is like playing all the
    # notes at once. Think ‘capacitors all charged to different voltages, 
    # each oscillating, and you’re measuring the net field.’
    for x in range(x_range):
        fx = pow(a, x, N)
        wave = mod_exp_wave(fx, t)
        superposed += wave

    # Step 3: The FFT - find the strongest frequencies.
    # The rfft function acts like a spectrum analyzer, telling us which
    # frequencies are most dominant in our combined signal.
    yf = np.abs(rfft(superposed))
    xf = rfftfreq(len(t), dt)

    # Find the top 5 frequency peaks in our spectrum
    dominant_freqs = xf[np.argsort(yf)[-5:]]
    dominant_freqs.sort()

    # Step 4: The heuristic leap.
    # We guess that the spacing between dominant frequencies (delta_fs)
    # is related to the period. This is like hearing the overtones of a
    # guitar string and using their spacing to find the fundamental note.
    # It's an intuitive but "hand-wavy" guess.
    delta_fs = np.diff(dominant_freqs)
    estimated_period = int(round(1 / delta_fs[0])) if len(delta_fs) > 0 and delta_fs[0] != 0 else None

    # Step 5: The Shor finale.
    # If we have a good guess for the period 'r', we plug it into the
    # classical part of Shor's algorithm to find the factors.
    factor1, factor2 = None, None
    if estimated_period and estimated_period % 2 == 0:
        r = estimated_period
        try:
            val1 = pow(a, r // 2, N) - 1
            val2 = pow(a, r // 2, N) + 1
            factor1 = gcd(val1, N)
            factor2 = gcd(val2, N)
            if factor1 * factor2 != N:
                 factor1, factor2 = None, None
        except OverflowError:
            pass
            
    return factor1, factor2

Analysis: A Brilliant Idea with a Practical Flaw

This first attempt is conceptually powerful but fails in its implementation. The aliasing and the weak heuristic aren't just bugs; they're vital clues. They tell us that our method of encoding information into the signal is the problem, not the underlying idea of using waves. This is how science progresses: a beautiful theory crashes against a practical reality, forcing us to invent a more elegant approach.

Success: The Core Intuition	Flaw: The Implementation Details
It correctly captures the idea that a periodic structure in a sequence can be revealed as a spectral structure in a transformed signal.	Aliasing: The simple frequency encoding (100 + fx * 10) creates frequencies far too high for the sampling rate, leading to a distorted "shadow" in the FFT.
It uses the right final step: using the found period r to extract factors with the gcd trick.	Weak Heuristic: The 1 / Δf estimation for the period is not mathematically rigorous and often fails to find the true period from the messy, aliased spectrum.

Transition

Our first attempt was like trying to listen for a specific melody in a room where every instrument is playing a different note at maximum volume. The idea was right, but the execution was cacophony. For our next attempt, we need to stop shouting with frequencies and start whispering with phase.

--------------------------------------------------------------------------------

2. A More Direct Approach: Encoding Numbers as Phases

The New Strategy: From Frequencies to Phases

The second version makes a crucial shift in thinking. Instead of creating a complex time-domain signal with many different frequencies, we will represent the sequence f(x) directly as a series of phases—points on a circle in the complex plane. This approach is more abstract, but it's much closer to how the Quantum Fourier Transform (QFT) at the heart of Shor's algorithm actually works.

Instead of assigning each number a unique musical note (frequency), we are now assigning it a unique position on a clock face (phase). An FFT on this sequence of clock-face positions is a much more direct way of asking: "What is the fundamental rotational symmetry of this sequence?" This is far closer to how a Quantum Fourier Transform (QFT) operates, as a QFT is fundamentally a transformation on phases.

Code Walkthrough: The Working Emulator

Let's walk through the complete, working code. Notice how much cleaner and more direct the logic becomes when we switch from frequencies to phases.

import numpy as np
from math import gcd

def harmonic_period_and_factors(N, a, x_range=60):
    """
    Harmonic Shor emulator using phase encoding.
    """
    # Step 1: Generate the modular exponentiation sequence.
    # This is the raw material we want to analyze.
    fx_values = [pow(a, x, N) for x in range(x_range)]
    L = x_range

    # Step 2: Encode as phases (unit-magnitude complex numbers).
    # This is the crucial leap. We map each f(x) value to a point
    # on the unit circle in the complex plane. This clean, mathematical
    # encoding avoids all the aliasing noise of our first attempt.
    y = np.exp(2j * np.pi * np.array(fx_values) / N)

    # Step 3: FFT on the sequence of phases.
    # We now apply the FFT directly to our sequence. This asks:
    # "What is the fundamental frequency of this pattern of rotations?"
    # The answer, k_peak, will reveal the sequence's period.
    Y = np.fft.fft(y)
    mags = np.abs(Y)
    
    # We ignore the DC component (k=0) and find the biggest peak.
    search = mags[1:L // 2]
    if search.size == 0: return None
    k_peak = int(np.argmax(search)) + 1
    
    # This is a standard and robust way to estimate the period from a DFT peak.
    r_est = round(L / k_peak) if k_peak != 0 else None
    if r_est is None or r_est <= 0: return None

    # Step 4: Refine and verify the period candidate.
    # We don't blindly trust the FFT. We use its estimate 'r_est' to guide
    # a search for the true, mathematically exact period.
    best_r = None
    best_score = -1.0
    for r in range(max(1, r_est - 5), min(L, r_est + 6)):
        if r <= 0: continue
        # We check how often f(x) actually equals f(x + r).
        matches = sum(1 for x in range(L - r) if fx_values[x] == fx_values[x + r])
        score = matches / (L - r) if (L - r) > 0 else 0.0
        if score > best_score:
            best_score = score
            best_r = r
    r = best_r

    # Step 5: Use the confirmed period 'r' in the Shor finale.
    if r and r % 2 == 0:
        v = pow(a, r // 2, N)
        if v not in (1, N - 1): # Avoid trivial roots of unity
            factor1 = gcd(v - 1, N)
            factor2 = gcd(v + 1, N)
            if factor1 * factor2 == N and factor1 > 1 and factor2 > 1:
                return (factor1, factor2)

    return None

This two-step process of estimation and refinement is a masterclass in computational physics. We use a "blurry" tool from signal processing (the FFT) to find a high-probability candidate, and then we use a "sharp" tool from pure mathematics (fx_values[x] == fx_values[x + r]) to confirm it with absolute certainty. Never trust a measurement without verification.

Analysis: Why This Version Succeeds

This script works reliably because it addresses all the shortcomings of the first attempt.

• Clean Encoding: By using phases, it avoids the aliasing and noise problems of the multi-frequency approach.
• Direct Analysis: The FFT is applied directly to the object of interest (the sequence's structure), not a time-domain proxy.
• Verification Step: The refinement loop ensures that the period found by the FFT is not just a random harmonic but the true, mathematically correct period of the sequence.

This combination of signal processing and mathematical verification is powerful, leading to successful factorizations as shown in this sample output:

N = 209, a = 12 → 209 = 11 × 19

Transition

We now have a classical algorithm that successfully finds the period and factors numbers. But what if this process doesn't happen in isolation? What if it's influenced by the very nature of prime numbers themselves?

--------------------------------------------------------------------------------

3. The Grand Unification: The Prime Resonator

The New Theory: Factoring as Resonance

Here, we pivot from clever engineering to genuine theoretical physics. We're about to ask a wild question: what if the Shor sequence isn't an isolated phenomenon, but is instead constantly interacting with a background field generated by the prime numbers themselves? This leads to the idea of the "Prime Resonator":

"We will build a shared 'resonator' where two patterns live: the local periodic orbit of a^x mod N and the global structure of prime numbers. Factoring becomes the act of observing how these two patterns interfere and align with each other."

Deconstructing the Resonator Code

The resonator is built from two core components, which are then analyzed with new tools.

The Shor Order Field (shor_phase_field)	The Prime Curvature Field (zeta_waveform)
What it represents: The local, periodic orbit of the base a inside the world of numbers modulo N.	What it represents: The global, universal structure of prime numbers, where each prime p contributes a phase based on log(p).
How it's built: Takes each value fx = a^x mod N and encodes it as a phase added to a sine wave at a shared base_freq.	How it's built: Takes each prime number p and encodes its "position" using log(p) as a phase added to a cosine wave at the same base_freq.

Two new analytical tools are used on the combined field:

• The Shared Carrier: Both fields use the same base_freq. This is a critical design choice. It means all the unique information is now stored in the phase, not the frequency, allowing the two fields to interfere directly with each other.
• The Hilbert Transform: Since we've intentionally placed both the Shor and Prime information onto a single carrier frequency, a standard FFT would just show a huge spike at that frequency. The interesting information is no longer in what frequencies are present, but in how their amplitudes and phases interfere over time. The Hilbert transform is the precise mathematical tool for this job; it demodulates the signal, stripping away the carrier to reveal the "beat"—the envelope—that contains the signature of their interaction. It's analogous to an AM radio demodulator.

The Full Process: Finding Factors via Resonance

The final algorithm is a beautiful synthesis of all the previous ideas, summarized in the code's main execution block.

from scipy.signal import hilbert

# --- Configuration for the Resonator ---
N = 1000          # Limit for the prime structure
samples = 8192    # FFT resolution
T = 30.0          # Time duration in seconds
base_freq = 10    # Shared carrier frequency for all encodings
a = 7             # Modular base for Shor's sequence
mod_N = 223       # The number we want to factor
phase_shift = np.pi/2 # Phase alignment between systems

# Time axis setup
t = np.linspace(0, T, samples)
dt = t[1] - t[0]

# --- Step 1: Create the Shor and Prime fields ---
# The Shor field encodes the local orbit a^x mod N as phases on a sine wave.
shor_field = shor_phase_field(a=a, N=mod_N, t=t, phase_shift=phase_shift)
# The Riemann/Prime field encodes the global prime structure as phases on a cosine wave.
riemann_field = zeta_waveform(limit=N, t=t, phase_shift=phase_shift)

# --- Step 2: Combine them into an interference pattern ---
combined_field = shor_field + riemann_field

# (Optional Step: Envelope analysis via Hilbert Transform)
# The Hilbert transform reveals the "beat" of the interference.
analytic_signal = hilbert(combined_field)
envelope = np.abs(analytic_signal)

# --- Step 3: Analyze the FFT of the combined signal ---
yf = np.abs(rfft(combined_field))
xf = rfftfreq(len(t), dt)
top_indices = np.argsort(yf)[-10:][::-1]
dominant_freqs = xf[top_indices[:5]]

# --- Step 4: Estimate a candidate period 'r' ---
deltas = np.diff(sorted(dominant_freqs))
if len(deltas) > 0 and deltas[0] != 0:
    rough_r = int(round(1 / deltas[0]))

    # --- Step 5: Refine 'r' with the strict modular condition ---
    best_r = None
    for r_candidate in range(max(2, rough_r - 5), rough_r + 6):
        if pow(a, r_candidate, mod_N) == 1:
            best_r = r_candidate
            break

    # --- Step 6: Use the confirmed 'r' to find factors ---
    if best_r and best_r % 2 == 0:
        x_val = pow(a, best_r // 2, mod_N)
        factor1 = gcd(x_val - 1, mod_N)
        if 1 < factor1 < mod_N:
            print(f"Factors of {mod_N}: {factor1} × {mod_N // factor1}")

Transition

This final script is more than just a factoring tool; it's a classical simulation of a new, unified theory of arithmetic. Let's summarize what this 'Prime Resonator' theory truly means.

--------------------------------------------------------------------------------

4. Conclusion: From a Clever Hack to a New Theory

Synthesize the Journey

Our journey took us through three distinct stages, each building on the last to arrive at a deeper understanding:

• Stage 1: A simple, intuitive frequency encoding that captured the core idea but was technically flawed.
• Stage 2: A robust phase encoding that worked reliably by analyzing the sequence directly and verifying its guess.
• Stage 3: A profound field resonance model that unified the local Shor orbit with the global structure of primes.

The Prime Resonator Theory in a Nutshell

The final model achieves a physicist's dream: it unifies two seemingly disparate mathematical domains—the local, group-theoretic world of modular arithmetic and the global, analytic world of prime numbers—within a single physical framework. It reimagines factoring N as a physical measurement: we are measuring the "resonant overlap" between a local field generated by the sequence a^x mod N and a global field generated by the prime numbers. The hidden period r, and therefore the factors of N, are revealed by the spectral structure of their interference. Factoring becomes an act of spectroscopy.

The Conceptual Upgrade for Quantum Computing

This model offers a powerful conceptual upgrade for the future of quantum computing. The standard view of Shor's algorithm involves running it in a "flat" Hilbert space. The Prime Resonator theory suggests embedding Shor’s circuit in a prime-shaped Hamiltonian landscape, so the quantum Fourier transform is doing spectroscopy in a medium whose ground modes are already tuned to prime geometry. In short, Shor's algorithm becomes "period finding in a prime-curved Hilbert space."

This new vision reframes the entire enterprise:

"Quantum computing gets reframed as: 'Build Hamiltonians whose spectra align with arithmetic structures (primes, zeta, orders, factors), then use the device as a physical spectrometer for number-theoretic fields.'"

Duh!