5D Library › Mayan Tzolkin Modular Gears, Oracle-Cross Involutions and Sixty-Four-Gate Network Percolation · 中文

Chapter 6. Base Rates in the Real Sky: an Ephemeris, Correlated Activations and Twelve Profiles

A low-precision ephemeris

To recompute the base rates of Chapter 5 on real planetary positions one needs an ephemeris. The program uses the approximate Keplerian elements published by the Jet Propulsion Laboratory (valid from 1800 to 2050) for the heliocentric positions of Mercury to Pluto, subtracts the Earth-Moon barycentre to obtain geocentric longitudes and adds precession to refer them to the equinox of date (Standish, n.d.); the Moon uses the six largest terms of its longitude and the node is the mean node (Meeus 1998). The design moment is found by solving “the Sun’s longitude 88 degrees earlier”.

Calculation

# Chapter 6. p10: A low-precision ephemeris and the 88-degree "design".
# Planets: JPL approximate Keplerian elements, valid 1800-2050 (Standish),
# heliocentric J2000 ecliptic, made geocentric by subtracting the
# Earth-Moon barycentre, plus general precession to the equinox of date.
# Moon: the six largest terms of its longitude; node: mean node.
# The design moment is when the Sun stood 88 degrees of longitude earlier.
from math import sin, cos, atan2, radians, degrees, sqrt

EL = {  # a, e, I, L, long. peri, node; then rates per Julian century
    "Mercury": (0.38709927, 0.20563593, 7.00497902, 252.25032350,
                77.45779628, 48.33076593, 0.00000037, 0.00001906,
                -0.00594749, 149472.67411175, 0.16047689, -0.12534081),
    "Venus": (0.72333566, 0.00677672, 3.39467605, 181.97909950,
              131.60246718, 76.67984255, 0.00000390, -0.00004107,
              -0.00078890, 58517.81538729, 0.00268329, -0.27769418),
    "EMB": (1.00000261, 0.01671123, -0.00001531, 100.46457166,
            102.93768193, 0.0, 0.00000562, -0.00004392, -0.01294668,
            35999.37244981, 0.32327364, 0.0),
    "Mars": (1.52371034, 0.09339410, 1.84969142, -4.55343205,
             -23.94362959, 49.55953891, 0.00001847, 0.00007882,
             -0.00813131, 19140.30268499, 0.44441088, -0.29257343),
    "Jupiter": (5.20288700, 0.04838624, 1.30439695, 34.39644051,
                14.72847983, 100.47390909, -0.00011607, -0.00013253,
                -0.00183714, 3034.74612775, 0.21252668, 0.20469106),
    "Saturn": (9.53667594, 0.05386179, 2.48599187, 49.95424423,
               92.59887831, 113.66242448, -0.00125060, -0.00050991,
               0.00193609, 1222.49362201, -0.41897216, -0.28867794),
    "Uranus": (19.18916464, 0.04725744, 0.77263783, 313.23810451,
               170.95427630, 74.01692503, -0.00196176, -0.00004397,
               -0.00242939, 428.48202785, 0.40805281, 0.04240589),
    "Neptune": (30.06992276, 0.00859048, 1.77004347, -55.12002969,
                44.96476227, 131.78422574, 0.00026291, 0.00005105,
                0.00035372, 218.45945325, -0.32241464, -0.00508664),
    "Pluto": (39.48211675, 0.24882730, 17.14001206, 238.92903833,
              224.06891629, 110.30393684, -0.00031596, 0.00005170,
              0.00004818, 145.20780515, -0.04062942, -0.01183482)}

def helio(name, T):
    v = EL[name]
    a, e, I, L, wb, Om = (v[i] + v[i + 6] * T for i in range(6))
    M = radians((L - wb + 180) % 360 - 180)
    E = M + e * sin(M)
    for _ in range(8):
        E -= (E - e * sin(E) - M) / (1 - e * cos(E))
    xp, yp = a * (cos(E) - e), a * sqrt(1 - e * e) * sin(E)
    w, Om, I = radians(wb - Om), radians(Om), radians(I)
    x = ((cos(w) * cos(Om) - sin(w) * sin(Om) * cos(I)) * xp
         + (-sin(w) * cos(Om) - cos(w) * sin(Om) * cos(I)) * yp)
    y = ((cos(w) * sin(Om) + sin(w) * cos(Om) * cos(I)) * xp
         + (-sin(w) * sin(Om) + cos(w) * cos(Om) * cos(I)) * yp)
    return x, y

def moon(d):
    Lp, D = 218.3164477 + 13.17639648 * d, 297.8501921 + 12.19074912 * d
    M, Mp = 357.5291092 + 0.98560028 * d, 134.9633964 + 13.06499295 * d
    F = 93.2720950 + 13.22935024 * d
    r = radians
    return (Lp + 6.289 * sin(r(Mp)) + 1.274 * sin(r(2 * D - Mp))
            + 0.658 * sin(r(2 * D)) + 0.214 * sin(r(2 * Mp))
            - 0.186 * sin(r(M)) - 0.114 * sin(r(2 * F))) % 360

def positions(jd):
    d = jd - 2451545.0
    T = d / 36525
    prec = 1.396971 * T
    ex, ey = helio("EMB", T)
    out = {"Sun": (degrees(atan2(-ey, -ex)) + prec) % 360}
    out["Earth"] = (out["Sun"] + 180) % 360
    out["Moon"] = moon(d)
    out["NNode"] = (125.0445479 - 0.0529537648 * d) % 360
    out["SNode"] = (out["NNode"] + 180) % 360
    for p in ("Mercury", "Venus", "Mars", "Jupiter", "Saturn", "Uranus",
              "Neptune", "Pluto"):
        x, y = helio(p, T)
        out[p] = (degrees(atan2(y - ey, x - ex)) + prec) % 360
    return out

def sun(jd):
    return positions(jd)["Sun"]

def design_jd(jd):
    target = (sun(jd) - 88) % 360
    t = jd - 88 / 0.9856
    for _ in range(6):
        t += ((target - sun(t) + 180) % 360 - 180) / 0.9856
    return t

if __name__ == "__main__":
    def rel(a, b):
        return (a - b + 180) % 360 - 180
    P = positions
    nm, op, gc = P(2451550.26), P(2459136.47), P(2459205.26)
    print("   test (published event)                 ours   expected")
    print("   Sun, 2000-01-01 12h TT                {:7.2f}   280.37".format(
        P(2451545.0)["Sun"]))
    print("   Moon - Sun, new moon 2000-01-06 18:14 {:7.2f}     0".format(
        rel(nm["Moon"], nm["Sun"])))
    print("   Mars - Sun, opposition 2020-10-13 23:20 {:5.2f}   180".format(
        rel(op["Mars"], op["Sun"]) % 360))
    print("   Jupiter - Saturn, 2020-12-21 18:20    {:7.2f}     0.1".format(
        abs(rel(gc["Jupiter"], gc["Saturn"]))))
    print("   Jupiter then (0 Aqu 29' = 300.48)     {:7.2f}   300.48".format(
        gc["Jupiter"]))
    gaps = [jd - design_jd(jd) for jd in
            [2451545.0 + 365.25 * i / 24 for i in range(24)]]
    print("   88 deg of solar arc lasts {:.2f} to {:.2f} days".format(
        min(gaps), max(gaps)))
#    test (published event)                 ours   expected
#    Sun, 2000-01-01 12h TT                 280.38   280.37
#    Moon - Sun, new moon 2000-01-06 18:14    0.04     0
#    Mars - Sun, opposition 2020-10-13 23:20 180.01   180
#    Jupiter - Saturn, 2020-12-21 18:20       0.05     0.1
#    Jupiter then (0 Aqu 29' = 300.48)      300.49   300.48
#    88 deg of solar arc lasts 86.61 to 92.00 days

The program checks the ephemeris against a few published events: the Sun’s longitude at 12h on 1 January 2000 is 280.38 degrees (expected 280.37); at the new moon of 6 January 2000 the Moon and Sun differ by 0.04 degrees; at the opposition of Mars on 13 October 2020, Mars and the Sun differ by 180.01 degrees; at the great conjunction of 21 December 2020, Jupiter and Saturn differ by 0.05 degrees, with Jupiter at 300.49 (published as 0 degrees 29 minutes of Aquarius, that is 300.48). For gates 5.625 degrees wide this accuracy is more than enough. The Sun takes 86.61 to 92.00 days to cover 88 degrees, depending on the season, because the Earth moves faster near perihelion.

Correlated activations

Calculation

# Chapter 6. p11: The same chart rules on real sky positions.
# Births uniform in time from 1950 to 2029. Each chart uses the 13 bodies
# of p10 at birth and at the design moment (Sun 88 degrees earlier), gates
# from the wheel of p06 (gate 41 at 302 degrees), and the centre and type
# rules of p09. Correlations the independence model ignores: Earth is
# opposite the Sun, the nodes opposite each other, Mercury and Venus stay
# near the Sun, slow planets barely move in 88 days. Composite: the gates
# of two independent births pooled (consecutive samples paired).
import importlib.util
import random

def load(name):
    spec = importlib.util.spec_from_file_location(name, name + ".py")
    m = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(m)
    return m

eph = load("p10_ephemeris")
rules = load("p09_centres_types")
HD = (41, 19, 13, 49, 30, 55, 37, 63, 22, 36, 25, 17, 21, 51, 42, 3, 27,
      24, 2, 23, 8, 20, 16, 35, 45, 12, 15, 52, 39, 53, 62, 56, 31, 33, 7,
      4, 29, 59, 40, 64, 47, 6, 46, 18, 48, 57, 32, 50, 28, 44, 1, 43, 14,
      34, 9, 5, 26, 11, 10, 58, 38, 54, 61, 60)

def gate(lon):
    return HD[int(((lon - 302) % 360) / 5.625)]

def chart(jd):
    gates = [gate(x) for x in eph.positions(jd).values()]
    gates += [gate(x) for x in eph.positions(eph.design_jd(jd)).values()]
    return gates

if __name__ == "__main__":
    rng = random.Random(72011)
    lo, hi, N = 2433282.5, 2462502.5, 60000
    samples, distinct, sets = [], 0, []
    for _ in range(N):
        g = set(chart(rng.uniform(lo, hi)))
        distinct += len(g)
        sets.append(g)
        samples.append(rules.analyse(g))
    print("   mean distinct gates: {:.3f} (independence model 21.5033)"
          .format(distinct / N))
    print("   mean conducting channels: {:.3f} (independence model 3.9603)"
          .format(sum(s[0] for s in samples) / N))
    none = sum(s[1] == 0 for s in samples) / N
    se = (none * (1 - none) / N) ** 0.5
    print("   P(no centre defined) = {:.4f} +/- {:.4f} (indep. 0.00462)"
          .format(none, 1.96 * se))
    rules.summary(samples, "sky positions, 1950-2029")
    comp = [rules.analyse(sets[i] | sets[i + 1]) for i in range(0, N, 2)]
    c = [x[0] for x in comp]
    m = sum(c) / len(c)
    v = sum((x - m) ** 2 for x in c) / (len(c) - 1)
    print("   composite of two births: channels mean {:.3f}, variance {:.3f}"
          .format(m, v))
    print("     no channel in the composite: {} of {}".format(
        sum(x == 0 for x in c), len(c)))
#    mean distinct gates: 19.759 (independence model 21.5033)
#    mean conducting channels: 3.569 (independence model 3.9603)
#    P(no centre defined) = 0.0084 +/- 0.0007 (indep. 0.00462)
#    sky positions, 1950-2029: mean defined centres 4.855
#      Generator         0.3528
#      Manifesting Gen.  0.3232
#      Projector         0.2164
#      Manifestor        0.0993
#      Reflector         0.0084
#      definition groups 1/2/3/4: 0.3805 0.4754 0.1279 0.0078
#    composite of two births: channels mean 9.962, variance 5.642
#      no channel in the composite: 0 of 30000

Over 60000 charts with birth moments uniform between 1950 and 2029, the mean number of active gates is 19.759, fewer than the 21.5033 of the independence model: the opposite Earth and south node, the inner planets near the Sun and the almost stationary outer planets make activations overlap. The mean number of conducting channels falls accordingly to 3.569.

The share with nothing conducting (Reflectors) is 0.0084, with a 95% confidence half-width of 0.0007, about twice the 0.00462 of the independence model but still below one per cent. The shares of the other types are: Generators 0.3528, Manifesting Generators 0.3232, Projectors 0.2164, Manifestors 0.0993; single definition 0.3805, split 0.4754, triple split 0.1279, quadruple split 0.0078. A composite of two charts conducts 9.962 channels on average, with variance 5.642; of 30000 composites not one has nothing conducting.

Shares of the types under two models: independent uniform gates and real sky positions 1950-2029 (p09, p11).

Evidence

Conclusion: “about one per cent are Reflectors” is a base rate that can be computed. In this book’s model it is about 0.0084; it comes entirely from the combinatorial probability that 26 activations land on both ends of one of 36 channels and from the correlations between bodies, and needs no other explanation.

Why there are only twelve profiles

A Human Design “profile” combines the line of the birth Sun and the line of the design Sun. Lines are 0.9375 degrees wide and numbered continuously round the wheel; the design Sun is exactly 88 degrees, or 93.8667 lines, behind.

Calculation

# Chapter 6. p12: Why there are only 12 "profiles", and what an hour of
# birth-time error changes.
# A line is 0.9375 degrees; six lines make a gate and lines run on round
# the wheel. The design Sun is exactly 88 degrees (93.8667 lines) behind
# the birth Sun, so the design line is the birth line minus 4 or minus 3
# (mod 6): 6 x 2 = 12 profiles, with weights 0.8667 and 0.1333 per line.
# Sensitivity: recompute a chart 1 or 2 hours later (p10, p11 rules).
import importlib.util
import random

def load(name):
    spec = importlib.util.spec_from_file_location(name, name + ".py")
    m = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(m)
    return m

eph = load("p10_ephemeris")
pop = load("p11_population_model")
rules = load("p09_centres_types")

def line(lon):
    return int(((lon - 302) % 360) / 0.9375) % 6 + 1

if __name__ == "__main__":
    off = 88 / 0.9375
    frac = off - int(off)
    print("   88 deg = {:.4f} lines; fraction {:.4f}".format(off, frac))
    exact = {}
    for p in range(1, 7):
        exact[(p, (p - 5) % 6 + 1)] = frac / 6
        exact[(p, (p - 4) % 6 + 1)] = (1 - frac) / 6
    rng = random.Random(72012)
    N, count = 20000, {}
    lo, hi = 2433282.5, 2462502.5
    for _ in range(N):
        jd = rng.uniform(lo, hi)
        key = (line(eph.sun(jd)), line(eph.sun(eph.design_jd(jd))))
        count[key] = count.get(key, 0) + 1
    print("   profile  exact    simulated")
    for key in sorted(exact):
        print("   {}/{}     {:.4f}   {:.4f}".format(
            key[0], key[1], exact[key], count.get(key, 0) / N))
    print("   other profiles observed: {}".format(
        sum(v for k, v in count.items() if k not in exact)))
    for hours in (1, 2):
        moved = {"gates": 0, "type": 0, "Moon gate": 0, "Moon line": 0}
        M = 4000
        for _ in range(M):
            jd = rng.uniform(lo, hi)
            a, b = pop.chart(jd), pop.chart(jd + hours / 24)
            moved["gates"] += set(a) != set(b)
            moved["type"] += (rules.analyse(set(a))[3] !=
                              rules.analyse(set(b))[3])
            ma = eph.positions(jd)["Moon"]
            mb = eph.positions(jd + hours / 24)["Moon"]
            moved["Moon gate"] += pop.gate(ma) != pop.gate(mb)
            moved["Moon line"] += line(ma) != line(mb)
        print("   birth time +{} h changes: ".format(hours) + ", ".join(
            "{} {:.3f}".format(k, v / M) for k, v in list(moved.items())[:2]))
        print("                            " + ", ".join(
            "{} {:.3f}".format(k, v / M) for k, v in list(moved.items())[2:]))
#    88 deg = 93.8667 lines; fraction 0.8667
#    profile  exact    simulated
#    1/3     0.1444   0.1422
#    1/4     0.0222   0.0223
#    2/4     0.1444   0.1444
#    2/5     0.0222   0.0226
#    3/5     0.1444   0.1440
#    3/6     0.0222   0.0232
#    4/1     0.0222   0.0227
#    4/6     0.1444   0.1454
#    5/1     0.1444   0.1438
#    5/2     0.0222   0.0228
#    6/2     0.1444   0.1431
#    6/3     0.0222   0.0233
#    other profiles observed: 0
#    birth time +1 h changes: gates 0.210, type 0.027
#                             Moon gate 0.095, Moon line 0.581
#    birth time +2 h changes: gates 0.396, type 0.044
#                             Moon gate 0.201, Moon line 1.000

Let the birth Sun lie at position u∈[0,1)u \in [0, 1) within its line (in units of the line width). Going back 93.8667 lines, the design line is the birth line minus 4 (modulo 6) if u<0.8667u < 0.8667 and minus 3 otherwise. Each birth line therefore pairs with only two design lines, 6×2=126 \times 2 = 12 combinations: exactly the 12 profiles Human Design lists. The first kind (1/3, 2/4, 3/5, 4/6, 5/1, 6/2) has probability 0.1444 each and the second (1/4, 2/5, 3/6, 4/1, 5/2, 6/3) 0.0222 each, more than six times less. The program confirms this on 20000 random births, with no thirteenth combination.

Exact probabilities of the twelve profiles (p12).

Errors in the birth time

If the birth time is one hour later, the set of active gates changes with probability 0.210 and the type with probability 0.027; the Moon’s gate changes with probability 0.095 and its line with probability 0.581. Two hours later these become 0.396, 0.044, 0.201 and 1.000: in two hours the Moon moves more than one line in longitude.

Hypothesis · not established

The author’s hypothesis (not yet tested): charts cast from birth times rounded to the hour or half hour on certificates mostly disagree with the true birth moment at the level of the Moon’s line, so “readings” at that level mainly reflect recording error. What would show it wrong: if charts cast from hospital times recorded to the minute and from rounded times agree on the Moon’s line significantly more often than this chapter’s model predicts, the hypothesis fails.

Summary

On real sky positions a single chart activates 19.759 gates on average and the share of Reflectors is about 0.0084, twice the independence model because activations are correlated. That there are only 12 profiles follows directly from 88 degrees being 93.8667 lines, and 6 of them are more than six times as likely as the other 6. An hour’s error in birth time changes the Moon’s line with probability 0.581.

References

Meeus, Jean. 1998. Astronomical Algorithms. 2nd ed. Willmann-Bell.
Standish, E. Myles. n.d. Keplerian Elements for Approximate Positions of the Major Planets. Jet Propulsion Laboratory, Solar System Dynamics. https://ssd.jpl.nasa.gov/planets/approx_pos.html.

Fan, Y. (2026). Mayan Tzolkin Modular Gears, Oracle-Cross Involutions and Sixty-Four-Gate Network Percolation: Coprime Cycle Synchronization, Antipode-Analog Permutations and Nine-Center Connected Components [玛雅卓尔金双模齿轮、神谕十字对合变换与六十四闸门网络渗流] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090193 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).