adoption helpers.py

"""Pure exact helpers for root adoption. No file or journal writes, no numbered steps.

Root may copy these functions into a frozen model module or import this file.
All compositions below are algebraic diagnostics unless source authorization is
supplied separately. Keep source/calendar/phase/endpoint tags in root records.
"""
from fractions import Fraction as F
from math import gcd


def solve_key_from_completion(base_days, target_days, selected_fraction):
    """Uses BOTH calibration and the posited partial/whole completion equality."""
    d0, d1, f = F(base_days), F(target_days), F(selected_fraction)
    den = d0 - d1*f
    if not den:
        raise ValueError('Completion system does not determine a finite Key here')
    return d1*(1-f)/den


def allocation(f, k):
    """Selection of fraction f, NOT sequential multiplication of Keys."""
    return 1 + F(f)*(F(k)-1)


def anchored(k, a, x):
    return F(a) + F(k)*(F(x)-F(a))


def retained_totals(u, v, priestly=F(25,23), prophetic=F(70,69)):
    u, v = F(u), F(v)
    return [u+v, prophetic*u+v, priestly*u+v]


def recover_retained_parts(native, prophetic):
    u = 69*(F(prophetic)-F(native))
    return [u, F(native)-u]


def component_defect(parts, factors):
    xs, ks = list(map(F,parts)), list(map(F,factors))
    if len(xs) != len(ks) or not sum(xs):
        raise ValueError('One factor per component and a nonzero source total required')
    selective = [x*k for x,k in zip(xs,ks)]
    effective = sum(selective)/sum(xs)
    uniform = [effective*x for x in xs]
    return {'effective':effective, 'selective':selective, 'uniform':uniform,
            'defect':[a-b for a,b in zip(selective,uniform)]}


def coarsening_commutes(blocks, component_factors, block_factors):
    """Coefficient criterion for C D = Dbar C on every fine-weight vector.

    blocks lists source component indices in each nonempty coarse block.
    Source membership/partition validity remains a separate supplied condition.
    """
    if len(blocks) != len(block_factors):
        raise ValueError('One factor per coarse block required')
    return all(F(component_factors[i]) == F(block_factors[b])
               for b, block in enumerate(blocks) for i in block)


def affine_stage_coset(first_key, second_key, first_pivot, second_pivot):
    """All-stage integer inputs for two fixed integer-pivot dilations.

    Returns a congruence class, not historical coordinates. Empty output means
    integer membership fails, not that rational chronological comparisons fail.
    """
    k1, k2, a, b = map(F, (first_key, second_key, first_pivot, second_pivot))
    if a.denominator != 1 or b.denominator != 1:
        raise ValueError('Normalize a declared h-grid first; pivots must be integral here')
    a, b = int(a), int(b)
    p1, q1, q2 = k1.numerator, k1.denominator, k2.denominator
    g = gcd(p1,q2)
    if (b-a) % g:
        return {'nonempty':False, 'g':g, 'pivot_difference_mod_g':(b-a)%g}
    reduced_modulus = q2//g
    t0 = 0 if reduced_modulus == 1 else ((b-a)//g)*pow(p1//g,-1,reduced_modulus)%reduced_modulus
    period = q1*reduced_modulus
    return {'nonempty':True, 'g':g, 'residue':(a+q1*t0)%period, 'period':period}


def whole_field_in_coset(points, coset):
    return bool(coset['nonempty']) and all((F(x)-coset['residue'])%coset['period'] == 0 for x in points)


def mixed_calendar_measure(parts, keys, calendar_days):
    if not len(parts) == len(keys) == len(calendar_days):
        raise ValueError('One Key and calendar measure per source component required')
    outputs = [F(x)*F(k) for x,k in zip(parts,keys)]
    volumes = [x*F(d) for x,d in zip(outputs,calendar_days)]
    return {'outputs':outputs, 'naked_sum':sum(outputs),
            'component_volumes':volumes, 'total_volume':sum(volumes)}