# A minimal AMPK-mTORC1 toggle switch (a modelling assumption, illustrative parameters).
# Nutrient signal s in [0, 1]: s = 1 fed (insulin and amino acids high), s = 0 fasted (energy stress).
#   dM/dt = 3 s / (1 + (A/0.5)^4) - M          mTORC1 (M): driven by nutrients, inhibited by AMPK
#   dA/dt = 3 (1 - s) / (1 + (M/0.5)^4) + 0.05 - A   AMPK (A): driven by energy stress, inhibited by mTORC1
# AMPK inhibits mTORC1 (via TSC2 and raptor); the reverse arm, mTORC1 dampening AMPK, is weaker
# and debated, so the steep mutual inhibition here is an assumption. ULK1, the autophagy initiator,
# is switched on by AMPK and off by mTORC1:  autophagy initiation = A/(A + 0.5) / (1 + (M/0.5)^2).
def settle(s, M, A, dt=0.01, T=60.0):
    for _ in range(int(T / dt)):
        dM = 3 * s / (1 + (A / 0.5) ** 4) - M
        dA = 3 * (1 - s) / (1 + (M / 0.5) ** 4) + 0.05 - A
        M += dM * dt; A += dA * dt
    return M, A

def flux(M, A):
    return A / (A + 0.5) / (1 + (M / 0.5) ** 2)

grid = [i / 10 for i in range(11)]
M, A = 0.0, 3.0                                   # start fully fasted
up = {}
for s in grid:                                    # slowly feed
    M, A = settle(s, M, A); up[s] = flux(M, A)
down = {}
for s in reversed(grid):                          # then slowly withdraw food
    M, A = settle(s, M, A); down[s] = flux(M, A)
print("nutrient signal s | autophagy initiation, rising nutrients | falling nutrients")
for s in grid:
    print(f"{s:17.1f} | {up[s]:38.2f} | {down[s]:17.2f}")
off = min(s for s in grid if up[s] < 0.2); on = max(s for s in grid if down[s] >= 0.2)
print(f"rising nutrients switch autophagy off at s = {off:.1f}; falling nutrients switch it back on only"
      f" at s = {on:.1f} (hysteresis)")
# nutrient signal s | autophagy initiation, rising nutrients | falling nutrients
#               0.0 |                                   0.86 |              0.86
#               0.1 |                                   0.85 |              0.85
#               0.2 |                                   0.83 |              0.83
#               0.3 |                                   0.81 |              0.81
#               0.4 |                                   0.79 |              0.03
#               0.5 |                                   0.76 |              0.01
#               0.6 |                                   0.71 |              0.01
#               0.7 |                                   0.60 |              0.01
#               0.8 |                                   0.00 |              0.00
#               0.9 |                                   0.00 |              0.00
#               1.0 |                                   0.00 |              0.00
# rising nutrients switch autophagy off at s = 0.8; falling nutrients switch it back on only at s = 0.3 (hysteresis)

# Feeding schedules run through the toggle switch of the previous program. Each meal pushes the
# nutrient signal s up by 0.8 (capped at 1); between meals s decays with time constant tau (8 h).
# M and A relax with a 1-hour time constant. 'Hours on' counts hours per day with autophagy
# initiation above 0.5, averaged over days 3-7. The clock is labelled in hours, but NO parameter is
# calibrated to human data: compare schedules with each other, do not read off real hours.
import math

def simulate(meals_per_day, days=7, dt=0.02, fast_day=None, tau=8.0):
    M, A, s, on = 0.5, 0.5, 0.5, 0.0
    steps = int(24 / dt)
    for d in range(days):
        eaten = set()
        for i in range(steps):
            h = i * dt
            for m in meals_per_day:
                if (d != fast_day) and m not in eaten and h >= m:
                    s = min(1.0, s + 0.8); eaten.add(m)
            s -= s / tau * dt
            dM = 3 * s / (1 + (A / 0.5) ** 4) - M
            dA = 3 * (1 - s) / (1 + (M / 0.5) ** 4) + 0.05 - A
            M += dM * dt; A += dA * dt
            if d >= 2 and A / (A + 0.5) / (1 + (M / 0.5) ** 2) > 0.5:
                on += dt
    return on / (days - 2)

SCHED = {"grazing: 6 small meals 07-22 h": (7, 10, 13, 16, 19, 22),
         "three meals 07, 12, 19 h": (7, 12, 19),
         "three meals + late snack 22 h": (7, 12, 19, 22),
         "16:8, meals 12 and 20 h": (12, 20),
         "16:8 early, meals 08 and 16 h": (8, 16)}
print("schedule                           | model hours per day with autophagy initiation 'on'")
for name, meals in SCHED.items():
    print(f"{name:34s} | {simulate(meals):6.1f}")
print(f"{'three meals, one day a week fasted':34s} | {simulate((7, 12, 19), days=9, fast_day=4):6.1f}")
# How fragile is this? Let the nutrient signal fade faster (tau = 6 h instead of 8 h):
print("with tau = 6 h: three meals", f"{simulate((7, 12, 19), tau=6.0):.1f}", "h, 16:8", f"{simulate((12, 20), tau=6.0):.1f}",
      "h, grazing", f"{simulate((7, 10, 13, 16, 19, 22), tau=6.0):.1f}", "h")
# schedule                           | model hours per day with autophagy initiation 'on'
# grazing: 6 small meals 07-22 h     |    0.0
# three meals 07, 12, 19 h           |    0.0
# three meals + late snack 22 h      |    0.0
# 16:8, meals 12 and 20 h            |   11.9
# 16:8 early, meals 08 and 16 h      |   11.9
# three meals, one day a week fasted |    4.1
# with tau = 6 h: three meals 22.4 h, 16:8 24.0 h, grazing 0.0 h

# Why a mouse's 24-hour fast is not a human's 24-hour fast. Kleiber's law: whole-body resting
# metabolic rate scales roughly as body mass^(3/4), so the rate PER KILOGRAM scales as mass^(-1/4).
# Masses: laboratory mouse 25 g, adult human 70 kg.
m_mouse, m_human = 0.025, 70.0
ratio = (m_human / m_mouse) ** 0.25
print(f"mass-specific metabolic rate, mouse / human: {ratio:.1f}x")
for h in (12, 24, 48):
    print(f"a {h:2d}-hour fast in a mouse ~ {h * ratio / 24:4.1f} days of a human's metabolic time"
          " (a naive scaling, see below)")
# Kleiber's formula itself: BMR (kcal/day) ~ 70 * M^0.75
for name, m in (("mouse", m_mouse), ("human", m_human)):
    bmr = 70 * m ** 0.75
    print(f"{name}: Kleiber estimate {bmr:7.1f} kcal/day = {bmr / m:5.0f} kcal per kg per day")
# Why the naive scaling is itself not a conversion table:
#  * different processes scale differently: liver glycogen in a fasted mouse is largely gone within
#    about 12-24 h, but autophagy in each tissue has its own kinetics (and the mouse brain showed
#    little induction even at 48 h in GFP-LC3 mice);
#  * mice are usually fasted during their active (dark) phase and are kept below thermoneutrality,
#    which raises their energy use further;
#  * in humans there is still no simple, non-invasive marker that times autophagic flux in tissues.
# mass-specific metabolic rate, mouse / human: 7.3x
# a 12-hour fast in a mouse ~  3.6 days of a human's metabolic time (a naive scaling, see below)
# a 24-hour fast in a mouse ~  7.3 days of a human's metabolic time (a naive scaling, see below)
# a 48-hour fast in a mouse ~ 14.5 days of a human's metabolic time (a naive scaling, see below)
# mouse: Kleiber estimate     4.4 kcal/day =   176 kcal per kg per day
# human: Kleiber estimate  1694.0 kcal/day =    24 kcal per kg per day