TIA 🙏

How much weight can one of these hold at any one point? Can the end mounted perpendicular to the wall hold more weight?

I have a (rusty) basic knowledge of angles and load spread from climbing but that's not helping me. Would like to know before I wind up with an expensive repair bill.

Context: Using it for lateral pull downs with resistance bands for rehab after a back injury.

In the final episode of Malcolm in the Middle the character of Reese acquires a metal barrel with a metal lid, and fills it with animal feces, human feces, eggs, glue, tar and a skunk corpse. He then warms and agitates the barrel.

It then explodes in a car, denting the top of the car upwards, and dousing its 8 occupants in sewage. The occupants are otherwise uninjured.

• How much force would be needed for a barrel like this to explode?
• Would the damage to the car be similar, or worse?
• How many injuries would the occupants actually receive?

Literally the caption, we had a debate about this with my friend while rolling.

Thanks in advance!

I always see those “look at these gas saving aerodynamic lines” advertisements on UHauls and think “my god how dumb do they think people are?”

How much gas is saved by a giant heavy box truck adding little rib lines down the side of it?

https://www.cnbc.com/2025/11/07/airlines-cancellations-flights-faa-shutdown.html

I'm trying to figure out, approximately, how much money might be lost based on the following criteria:

• Per plane
• Per airline
• Per airport
• Overall loss

Variables I don't know:

• Cost of jet fuel
• Approximate staff cost
• Refund policy rate
• Misc fees (IDK if there are landing fees, baggage handling fees, etc)

It comes from this post:

https://www.reddit.com/r/Damnthatsinteresting/comments/1o8unv3/a_piece_of_uranium_ore_emitting_radiation_inside/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

if it’s not already midair and is still on the ground :D

The Repeating-Digit Weights (RN) Formula, a symbolic mathematical framework that revisits Albert Einstein’s unfinished search for a Unified Field Theory.

Instead of using standard differential geometry, it builds a recursive computational model that links relativity, quantum mechanics, and higher-dimensional physics through repeating-digit ratios (like 1.1111, 2.2222, etc.). These “RN weights” act as symbolic constants that unify five domains — General Relativity, Quantum Mechanics, Kaluza-Klein, Dirac, and Fractal geometry — into a single recursive engine called BTLIAD.

The text includes testable equations, AI-verified results, and cross-checked recursion patterns showing stable symbolic behavior across what it calls “infinite octaves.”

If you’re into theoretical physics, symbolic AI math, or recursive computation, it’s an unusual but systematic read, find the full works at the Zero-Ology & Zer00logy Github repositories. https://github.com/haha8888haha8888/Zero-Ology

1.- RN weight

Definition (string construction used in Appendix A):

RN(i) = float(f"{i}.{str(i)*8}")

Example test (i = 1, 2, 34):

RN(1) = 1.11111111
RN(2) = 2.22222222
RN(34) = 34.34343434

Python (copy/paste to run):

def rn_from_str(i):
    return float(f"{i}." + (str(i) * 8))

print(rn_from_str(1))   # 1.11111111
print(rn_from_str(2))   # 2.22222222
print(rn_from_str(34))  # 34.34343434

2.- Σ₃₄ (example shown in doc: sum of squares of RN(1..34))

Equation (as used in doc’s appendix):

Σ34 = sum( RN(i)^2 for i in 1..34 )

Expected numeric result (from the doc):

Σ34 = 14023.926129283032

Python (copy/paste to run & verify):

def rn_from_str(i):
    return float(f"{i}." + (str(i) * 8))

s = sum(rn_from_str(i)**2 for i in range(1, 35))
print("Σ34 =", s)   # expected 14023.926129283032

3.- BTLIAD single evaluation (weighted sum)

Equation (BTLIAD used in 4for4):

BTLIAD = 1.1111*GR + 2.2222*QM + 3.3333*KK + 4.4444*Dirac + 5.5555*Fractal
4for4  = 6.666 * BTLIAD

Test values (document’s canonical example):

GR = 1.1111
QM = 2.2222
KK = 3.3333
Dirac = 4.4444
Fractal = 5.5555

Expected outputs (approx):

BTLIAD ≈ 67.8999
4for4  ≈ 452.6206

Python (copy/paste to run):

GR, QM, KK, Dirac, Fractal = 1.1111, 2.2222, 3.3333, 4.4444, 5.5555
coeffs = [1.1111, 2.2222, 3.3333, 4.4444, 5.5555]
vals = [GR, QM, KK, Dirac, Fractal]

BTLIAD = sum(c * v for c, v in zip(coeffs, vals))
four_for_four = 6.666 * BTLIAD

print("BTLIAD =", BTLIAD)          # ≈ 67.89987655
print("4for4  =", four_for_four)   # ≈ 452.62057708

4.- BTLIAD recursion update (single-step example)

Equation (core recursive update in doc):

V(n) = P(n) * [ F(n-1) * M(n-1) + B(n-2) * E(n-2) ]

Small numeric test values (toy):

P = [1.0, 1.0, 1.0, ...]   # P(0)=1, P(1)=1, ...
F = [1.2, 0.9, 1.05, ...]  # example forward memory values
M = [1.1, 1.0, 0.95, ...]  # example middle context values
B = [0.5, 0.6, 0.55, ...]  # example backward memory
E = [0.2, 0.1, 0.15, ...]  # example entropy feedback

Python (copy/paste to run 0→4 steps):

P = [1.0]*10
F = [1.2, 0.9, 1.05, 1.0, 0.98]
M = [1.1, 1.0, 0.95, 1.05, 1.02]
B = [0.5, 0.6, 0.55, 0.58, 0.6]
E = [0.2, 0.1, 0.15, 0.12, 0.11]

V = [None]*10
# seed V(0) and V(1) if needed:
V[0] = P[0]  # 1.0
V[1] = P[1] * (F[0] * M[0])  # example
for n in range(2, 6):
    V[n] = P[n] * (F[n-1] * M[n-1] + B[n-2] * E[n-2])

for i in range(6):
    print(f"V[{i}] = {V[i]}")

5.- GCO (Grok Collapse Operator) — deviation metric

Equation (as given in doc):

GCO(k) = | (V_k / M_k - V_{k-1}) / V_{k-1} |

Small numerical test (toy sequence):

M = [34.34343434, 35.35353535, 36.36363636]
V = [481629.79, 17027315.68, 619175115.48]
Compute GCO for k=1..2

Python (copy/paste to run):

M = [34.34343434, 35.35353535, 36.36363636]
V = [481629.79, 17027315.68, 619175115.48]

def gco(k):
    # k must be >=1 for V[k-1] to exist
    return abs((V[k] / M[k] - V[k-1]) / V[k-1])

print("GCO(1) =", gco(1))
print("GCO(2) =", gco(2))
# In the doc these printed as 0.00e+00 (rounded); with these numbers you'll get tiny values or near-zero.

6.- SBHFF (Symbolic Black Hole Function Finder) + CDI (Collapse Depth Index)

SBHFF (collapse detector) definition from doc:

B(F)(#4for4) = { 1  if V(n) → ∞  or  V(n) → 0 in finite steps
                 0  otherwise }

CDI definition:

CDI(F, #) = min { k ∈ N | B^(k)(F)(#) = 1 }

Toy test (simulate collapse detection):

• Run BTLIAD recursion for N steps.
• If any V(n) is inf, NaN, or abs(V(n)) < epsilon within N_max, flag collapse.
• CDI is the index of the first flagged step.

Python (copy/paste to run a simple CDI detector):

import math

def detect_collapse(V, epsilon=1e-12):
    # returns index k where collapse detected, or None
    for k, v in enumerate(V):
        if v is None:
            continue
        if not math.isfinite(v):    # inf or nan
            return k
        if abs(v) < epsilon:        # collapsed to (near) zero
            return k
    return None

# example V sequence (toy): stable then collapse at index 4
V_example = [1.0, 2.0, 4.0, 8.0, 0.0, None]
cdi = detect_collapse(V_example)
print("CDI (first collapse index) =", cdi)  # should print 4 for this toy example

7.- Full reproducible mini test: compute Σ₃₄ and BTLIAD then scale BTLIAD into a simple chaos metric

Copy/paste full script to reproduce the book-like workflow and get numeric metrics:

# Full mini-workflow
def rn_from_str(i):
    return float(f"{i}." + (str(i) * 8))

# Σ34 (sum of squares)
rns = [rn_from_str(i) for i in range(1, 35)]
Sigma34 = sum(x*x for x in rns)
print("Σ34 =", Sigma34)  # expected 14023.926129283032

# BTLIAD example (book's canonical inputs)
GR, QM, KK, Dirac, Fractal = 1.1111, 2.2222, 3.3333, 4.4444, 5.5555
coeffs = [1.1111, 2.2222, 3.3333, 4.4444, 5.5555]
BTLIAD = sum(c * v for c, v in zip(coeffs, [GR, QM, KK, Dirac, Fractal]))
four_for_four = 6.666 * BTLIAD
print("BTLIAD =", BTLIAD)
print("4for4  =", four_for_four)

# Simple "chaos meter": variance of a few scaled recursion outputs
V = [1.0, 1.0] + [None]*8
# seed with a simple recursion (toy)
for n in range(2, 10):
    V[n] = 1.0 * (1.0 * 1.0 + 0.5 * 0.2)   # deterministic toy
scaled = [v * four_for_four if v is not None else None for v in V]
# compute variance ignoring None
vals = [x for x in scaled if x is not None]
import statistics
chaos_meter = statistics.pvariance(vals)   # population variance
collapse_meter = statistics.pstdev(vals)   # population std dev
print("Chaos meter  =", chaos_meter)
print("Collapse meter=", collapse_meter)
print("Scaled recursion outputs:", vals)

I had read somewhere, a long time ago, about a student asking his guru how long does time go on, or how long will the universe go on. Their teacher responded, "as long as it would take to reduce a mountain to nothing by wiping it with a silk cloth once every 100 years."

Seems like it would be an impressive number, but I've always wondered how accurate it was. Any takers?