Spatial-Causal Geometry (SCG)

Why Do Galaxies Spin the Way They Do?

For nearly a century, astronomers have observed a quiet but persistent contradiction: galaxies spin too fast. The outer stars move as if held by invisible hands—far beyond what visible matter should allow. According to Newton’s law of gravity, these stars should slow down with distance. But they don’t.

Instead, the curves flatten. The velocity remains high, long after the luminous matter ends. This mismatch is one of modern astronomy’s most famous puzzles, and it has a name: the galactic rotation problem.

Most models solve this by adding something we can’t see: dark matter. But what if the stars are not lying—and nothing is missing? What if the problem is not the mass… but the math?

A Mystery Since 1933: Zwicky, Rubin, and the Rotating Sky

In 1933, Swiss astrophysicist Fritz Zwicky studied the Coma Cluster and made a shocking discovery: galaxies within the cluster were moving far too fast to be held together by the visible matter. To account for this, he proposed the existence of “dunkle Materie”—dark matter—an invisible substance whose gravity could explain the motions.

Zwicky’s proposal was bold, and largely overlooked. But in the 1970s, another scientist brought the mystery back into the spotlight—this time, within individual galaxies. Vera Rubin, working with W. Kent Ford, carefully measured how stars moved in spiral galaxies like Andromeda. What she found stunned the astrophysics community: the rotation curves didn’t fall. They flattened.

Rubin’s data was meticulous and unambiguous. It showed that Newtonian expectations failed—consistently and dramatically. The case for dark matter was no longer speculative; it was empirical. And yet, Rubin herself remained open-minded about the nature of the cause. In her words:

“If I could have my pick, I would like to learn that Newton’s laws must be modified in order to correctly describe gravitational interactions at large distances.”
— Vera Rubin (1980)

Spatial-Causal Geometry (SCG) enters not as a rejection of Rubin and Zwicky, but as a possible resolution to the very problem they saw so clearly. It offers a third path: not added matter, not tweaked force—but a change in perspective. What if the stars aren’t misbehaving? What if the space around them is telling the truth?

What SCG Says: It’s Not Mass That Moves Stars—It’s Geometry

Most models of galactic motion begin with force: how much mass is there, and how strongly does it pull? But Spatial-Causal Geometry (SCG) starts elsewhere. It begins with a different question:

What if motion isn’t caused by mass at all?
What if motion emerges from how space itself curves?

In SCG, space is not empty. It has structure—a causal-density field, written as \( \rho(x) \). This field tells us how “tightly woven” space is at every point. And where this field curves, things move. No invisible matter, no pulling forces—just local imbalances in geometry, like a ball rolling down a slope.

Instead of force causing acceleration, SCG says acceleration arises from the gradient of this curvature:

\( a(x) = c^2 \cdot \frac{d}{dx} \ln \rho(x) \)

Here, \( c \) is the causal speed limit—analogous to the speed of light—and \( \ln \rho(x) \) is the natural logarithm of the density field. When \( \rho(x) \) is flat, there’s no motion. When it curves, structures respond by accelerating. That’s all it takes.

This is the heart of SCG: movement is not commanded; it is permitted by curvature. Galaxies spin not because something is pulling on them, but because their space is curved in a very specific, very consistent way.

The SCG Rotation Curve Equation: Just One Line

If acceleration comes from the curvature of \( \ln \rho(x) \), then rotation—circular motion—emerges naturally from that geometry. In Spatial-Causal Geometry, the orbital velocity of a star at radius \( r \) is given by:

\( v(r) = A \cdot r^{(1 - B)/2} \)

This deceptively simple equation has only two free parameters:

• \( A \): a scaling factor, related to the curvature “strength” or density gradient amplitude
• \( B \): a dimensionless quantity that encodes the causal phase structure of the galaxy

To evaluate how well a curve fits a galaxy, we calculate the root-mean-square deviation (RMSD). This is a measure of the average error between the predicted velocities and the observed ones. The smaller the RMSD, the better the fit.

In SCG, causal phase structure refers to how the spatial curvature evolves as you move outward from the center of a galaxy. It's the pattern or “tempo” of how tightly or loosely space is curved, and how that pattern influences motion. When \( B \) is higher, curvature drops off more sharply—leading to falling rotation curves. When \( B \) is lower, curvature is shallower and more extended—resulting in flat or rising curves.

This structure isn’t imposed by external forces—it emerges from how space itself wants to bend. And \( B \) lets us read that curvature’s character directly from the stars.

Unlike Newtonian gravity, where velocity falls off as \( v \sim r^{-1/2} \), or dark matter models that require complex halo profiles, SCG gives you the full rotation curve from geometry alone. It doesn’t need to be patched with invisible mass. It just asks:

How does space curve here?

When you fit this curve to real galactic data, you’re not tuning a theory—you’re tracing the shape of space.

A Real Example: Fitting UGC 05829 with SCG

To see SCG in action, let’s look at a relatively quiet galaxy: UGC 05829. It’s a late-type spiral with a smooth rotation profile and just enough data points to resolve its causal structure clearly. This makes it a perfect first example for a single-phase SCG fit.

Below, the blue points show real observations of stellar velocity at different radii. The orange line is the SCG prediction, generated from the galaxy’s own geometric curvature:

\( v(r) = A \cdot r^{(1 - B)/2} \)

For UGC 05829, the SCG model found:

• \( A = 22.489 \)
• \( B = -0.154 \)
• \( RMSD = 1.12 km/s \)

Despite the simplicity—just a single phase and two parameters—the fit is remarkably precise. The low value of \( B \) means the causal gradient is nearly flat, which translates into a slow and steady rise in velocity across the disk.

This is the elegance of SCG: no added mass, no special forces. Just the curve of space—and how the stars respond to it.

How We Fit the Curve: From Data to Geometry

Every galaxy fit starts the same way: with a table of observations. For each radius \( r \), we’re given the orbital velocity \( v \)—how fast the stars are moving at that distance. This is the raw rotation curve.

SCG doesn’t simulate particles or halos. It simply asks: what geometric curve best describes these points, based on the equation:

\( v(r) = A \cdot r^{(1 - B)/2} \)

To find the best-fitting values of \( A \) and \( B \), we use a standard method from numerical analysis: nonlinear least squares optimization. Specifically, we minimize the root-mean-square deviation (RMSD) between the observed velocities and the predicted curve.

This means we’re solving:

\( \text{RMSD} = \sqrt{ \frac{1}{N} \sum_{i=1}^{N} (v_{\text{obs},i} - v_{\text{SCG}}(r_i; A, B))^2 } \)

We scan through candidate values of \( A \) and \( B \), adjust them automatically, and stop when the RMSD is as low as possible. The lower the RMSD, the tighter the match. For most of the 175 galaxies studied, SCG fits converge in milliseconds—fast, stable, and accurate.

When the galaxy is simple, like UGC 05829, a single curve is enough. When it’s more complex, we test for a breakpoint and consider a two-region model. But the principle is always the same: match the observed motion by finding the shape that space wants to be.

When One Curve Isn’t Enough: Dual-Region SCG Fitting

Not all galaxies follow a single smooth pattern. Some change character—gently or suddenly—as you move outward from the core. In SCG, these transitions are called causal phase shifts, and they show up as changes in the curvature of space itself.

To model these galaxies, we extend the basic SCG equation into two regions, each with its own parameters:

• Inner region: \( v(r) = A_1 \cdot r^{(1 - B_1)/2} \)
• Outer region: \( v(r) = A_2 \cdot r^{(1 - B_2)/2} \)

The point where the galaxy transitions from one curvature profile to another is called the breakpoint. We don’t choose it by eye—we find it by scanning every possible location and computing the total RMSD across both regions.

If the dual-fit RMSD improves by at least 20% compared to the single fit, we accept the dual model as a meaningful phase separation.

This isn’t just an algorithmic trick—it’s a geometric insight. A galaxy that changes causal structure is telling us something about how its inner and outer densities evolved. SCG listens carefully, and models both regions with precision.

Case Study: NGC 2903 — Two Curves, One Galaxy

NGC 2903 is a bright barred spiral galaxy, rich in structure and star formation. When we first attempt to fit it with a single SCG curve, the result is decent—but something feels off. The inner velocities rise too steeply, while the outer disk flattens more gently. A single causal phase can’t capture both behaviors at once.

So we let SCG ask a deeper question: is there a natural place to divide the curve? Using a breakpoint scan, the model splits the galaxy into two regions and fits each independently. The result is strikingly better.

SCG identifies the breakpoint at \( r = 2.88 \, \text{kpc} \), and returns these parameters:

• Inner region: \( A_1 = 114.661 \), \( B_1 = -0.337 \)
• Outer region: \( A_2 = 243.154 \), \( B_2 = 1.184 \)
• Total RMSD: 5.08 km/s (vs. 31.9 for single fit)

That’s an 84% improvement in RMSD—well beyond the 20% threshold. More importantly, the fit aligns beautifully with observation. The inner region reflects a gently curved basin with a lower causal-phase exponent \( B_1 = -0.337 \), while the outer region sharpens into a steeper curvature phase with \( B_2 = 1.184 \). This dual-profile structure captures the shift from central coherence to an extended outer gradient with remarkable fidelity.

This is the power of SCG’s dual-region modeling: it lets space speak with two voices, and listens to both.

Explore the Fits: SCG Results Across Galaxies

Click any “View” link to display the SCG rotation curve fit for that galaxy. Click column headers to sort.

×

How Does SCG Compare?

While Spatial-Causal Geometry approaches galactic motion from geometric principles—not through conventional force models—it’s still fair to ask: how well do its predictions match real data?

Below is a summary of RMSD (root-mean-square deviation) values reported by various models across similar galactic datasets. Lower RMSD indicates a closer match between model and observation.

These results speak for themselves. SCG isn’t just a different way of seeing—it’s also surprisingly precise. And all it needs is geometry.

Appendix: SCG Fit Code (Python)

This script applies the SCG causal-density velocity model to galactic rotation data. It evaluates both single and dual-region fits, selecting the model with the lowest RMSD. The equation used is \( v(r) = A \cdot r^{(1-B)/2} \), derived from curvature in \( \ln \rho(r) \).

📋 Copy
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
import os
import shutil
import pandas as pd

# --- SCG MODEL AND METRICS ---

def scg_velocity(x, A, B):
    """
    SCG rotation velocity model:
    v(r) = A * r^((1 - B)/2)
    This follows directly from SCG's causal-density curvature relation.
    """
    return A * x**((1 - B) / 2)

def rmsd(observed, predicted):
    """
    Computes root mean square deviation (RMSD) between observed and predicted values.
    Used to assess model fit quality.
    """
    return np.sqrt(np.mean((observed - predicted) ** 2))


# --- SINGLE-REGION SCG FIT ---

def fit_region(radius, velocity):
    """
    Fits the SCG model to a region of (radius, velocity) data.
    Returns best-fit parameters, predicted values, and RMSD.
    """
    if len(radius) < 4:
        return None  # Too few data points for a stable fit
    try:
        params, _ = curve_fit(scg_velocity, radius, velocity, p0=[100, 1.7])
        pred = scg_velocity(radius, *params)
        return params, pred, rmsd(velocity, pred)
    except RuntimeError:
        return None  # Fitting failed (e.g., numerical instability)


# --- DUAL-REGION SPLIT FIT SEARCH ---

def find_best_break(radius, velocity, min_gap=5):
    """
    Finds the best radius to split the dataset into two zones,
    minimizing combined RMSD of two SCG fits.
    """
    best_rmsd = float('inf')
    best_split = None
    best_fits = None

    for i in range(min_gap, len(radius) - min_gap):
        r_break = radius[i]
        left_mask = radius < r_break
        right_mask = radius >= r_break

        fit_left = fit_region(radius[left_mask], velocity[left_mask])
        fit_right = fit_region(radius[right_mask], velocity[right_mask])

        if fit_left and fit_right:
            total_rmsd = (
                fit_left[2] * np.sum(left_mask) +
                fit_right[2] * np.sum(right_mask)
            ) / len(radius)

            if total_rmsd < best_rmsd:
                best_rmsd = total_rmsd
                best_split = r_break
                best_fits = (fit_left, fit_right)

    return best_split, best_fits, best_rmsd


# --- PER-FILE (PER-GALAXY) FITTING LOGIC ---

def process_file(filepath, output_dir="graphs_final", processed_dir="processed_final", min_improvement=0.20):
    """
    Processes a single galaxy data file:
    - Performs global (single) SCG fit
    - Optionally applies dual-region split if significantly better
    - Generates a plot
    - Returns summary fit metrics
    """
    galaxy_name = os.path.basename(filepath).split('_')[0]

    with open(filepath, 'r') as file:
        lines = file.readlines()
    data = [line.strip().split() for line in lines if not line.startswith("#")]

    radius = np.array([float(row[0]) for row in data])
    v_obs = np.array([float(row[1]) for row in data])
    num_points = len(radius)

    global_fit = fit_region(radius, v_obs)
    if not global_fit:
        return {
            "Galaxy": galaxy_name,
            "Best Fit": "Failed",
            "Global RMSD": None,
            "Dual RMSD": None,
            "Break Radius": None,
            "A1": None, "B1": None, "A2": None, "B2": None,
        }

    global_rmsd = global_fit[2]
    use_dual = False
    break_radius, split_fits, dual_rmsd = None, (None, None), None

    # Try dual-region fit if there are enough data points
    if num_points >= 10:
        break_radius, split_fits, dual_rmsd = find_best_break(radius, v_obs)
        # Only switch to dual if improvement over single is meaningful
        if break_radius and global_rmsd > 0 and ((global_rmsd - dual_rmsd) / global_rmsd) >= min_improvement:
            use_dual = True

    # --- Visualization ---
    os.makedirs(output_dir, exist_ok=True)
    fig, ax = plt.subplots(figsize=(9, 5))
    ax.plot(radius, v_obs, 'o', label='Observed', markersize=4)

    if use_dual:
        fit_left, fit_right = split_fits
        ax.plot(radius[radius < break_radius], fit_left[1], '-', label=f'Inner Fit B={fit_left[0][1]:.3f}')
        ax.plot(radius[radius >= break_radius], fit_right[1], '-', label=f'Outer Fit B={fit_right[0][1]:.3f}')
        ax.axvline(break_radius, color='gray', linestyle='--', alpha=0.6, label=f'Break @ {break_radius:.2f} kpc')
        title = f'{galaxy_name} | Best Fit: Dual | RMSD: {dual_rmsd:.2f}'
    else:
        ax.plot(radius, global_fit[1], '-', label=f'Single Fit B={global_fit[0][1]:.3f}')
        title = f'{galaxy_name} | Best Fit: Single | RMSD: {global_rmsd:.2f}'

    ax.set_title(title)
    ax.set_xlabel('Radius (kpc)')
    ax.set_ylabel('Velocity (km/s)')
    ax.grid(True)
    ax.legend()
    plt.tight_layout()
    plt.savefig(f"{output_dir}/{galaxy_name}_best_fit.png")
    plt.close()

    # Move file to processed directory
    os.makedirs(processed_dir, exist_ok=True)
    shutil.move(filepath, os.path.join(processed_dir, os.path.basename(filepath)))
    print(filepath)

    return {
        "Galaxy": galaxy_name,
        "Datapoints": num_points,
        "Best Fit": "Dual" if use_dual else "Single",
        "Global RMSD": global_rmsd,
        "Dual RMSD": dual_rmsd if use_dual else None,
        "Break Radius": break_radius if use_dual else None,
        "A1": split_fits[0][0][0] if use_dual else global_fit[0][0],
        "B1": split_fits[0][0][1] if use_dual else global_fit[0][1],
        "A2": split_fits[1][0][0] if use_dual else None,
        "B2": split_fits[1][0][1] if use_dual else None,
    }


# --- BATCH PROCESSING LOOP ---

def batch_process():
    """
    Runs SCG fitting on all galaxy data files in the current directory
    (expects filenames ending with '_rotmod.dat').
    Outputs results to CSV.
    """
    results = []
    for filename in os.listdir():
        if filename.endswith("_rotmod.dat"):
            result = process_file(filename)
            if result:
                results.append(result)

    df = pd.DataFrame(results)
    df.to_csv("SCG_best_fit_summary.csv", index=False)
    print("✅ SCG model selection complete. Summary saved to SCG_best_fit_summary.csv.")


# --- ENTRY POINT ---

if __name__ == "__main__":
    batch_process()

References and Source Links

• Zwicky, F. (1933). Die Rotverschiebung von extragalaktischen Nebeln. Helvetica Physica Acta.
• Rubin, V. C., Ford, W. K. (1970). Rotation of the Andromeda Nebula from a Spectroscopic Survey of Emission Regions. Astrophysical Journal, 159, 379.
• McGaugh, S. S., Lelli, F., & Schombert, J. M. (2016). The radial acceleration relation in rotationally supported galaxies. Phys. Rev. Lett., 117(20), 201101.
• Li, P. et al. (2018). Mass Models for 175 Disk Galaxies. Astronomical Journal, 157(5), 202.
• Hallman, D. J. (2025). Calculating Galactic Rotation Curves Using Spatial-Causal Geometry. Zenodo.
• SPARC Database DOI 10.3847/0004-6256/152/6/157 & DOI 10.48550/arXiv.1606.09251http://astroweb.case.edu/SPARC/
• SCG Project Home: https://dhallman.com

For updates, examples, or implementation help, contact D. J. Hallman SCG@azfn.com.