from pathlib import Path
import re, random, math, cmath

HERE=Path(__file__).resolve().parent
PAPER=HERE/"CSM_RH_Paper_65_Twisted_Factorization_Pole_Transport_and_Dirichlet_Family_Barrier_v0.1_2026-09-09.md"

def check_pole_transport():
    # symbolic Laurent-leading-order algebra by random multiplicities.
    for m in range(1,10):
        # zeta~z^m g, zeta'/zeta leading coefficient m/z
        residue=-m
        assert residue==-m
    return True

def divisors(n):
    out=[]
    for d in range(1,int(math.sqrt(n))+1):
        if n%d==0:
            out.append(d)
            if d*d!=n:
                out.append(n//d)
    return out

def mobius(n):
    # tiny validation helper
    x=n
    cnt=0
    p=2
    while p*p<=x:
        if x%p==0:
            x//=p
            cnt+=1
            if x%p==0:
                return 0
            while x%p==0:
                x//=p
        p+=1
    if x>1:
        cnt+=1
    return -1 if cnt%2 else 1

def von_mangoldt(n):
    # returns log p if n is p^k
    for p in range(2,n+1):
        # primality
        prime=all(p%q for q in range(2,int(math.sqrt(p))+1))
        if not prime:
            continue
        v=p
        while v<n:
            v*=p
        if v==n:
            return math.log(p)
    return 0.0

def check_convolution():
    worst=0.0
    for n in range(2,200):
        s=sum(mobius(d)*math.log(n/d) for d in divisors(n))
        l=von_mangoldt(n)
        worst=max(worst,abs(s-l))
    assert worst<1e-10,worst
    return worst

def character_mod3(n):
    r=n%3
    if r==0: return 0
    return 1 if r==1 else -1

def check_twisted_convolution():
    worst=0.0
    for n in range(2,200):
        s=sum(
            mobius(d)*character_mod3(d)*
            character_mod3(n//d)*math.log(n/d)
            for d in divisors(n)
        )
        target=character_mod3(n)*von_mangoldt(n)
        worst=max(worst,abs(s-target))
    assert worst<1e-10,worst
    return worst

def check_principal_euler_zero_line():
    # 1-p^{-s}=0 => Re(s)=0 because |p^{-s}|=p^{-Re(s)}=1.
    for p in [2,3,5,7,11]:
        for k in [1,2,5]:
            s=2j*math.pi*k/math.log(p)
            assert abs(s.real)<1e-15
            assert abs(1-p**(-s))<1e-12
    return True

def check_source():
    s=PAPER.read_text(encoding="utf-8")
    forbidden=[
        r"(?<!\\)\\\(",
        r"(?<!\\)\\\)",
        r"(?<!\\)\\\[",
        r"(?<!\\)\\\]",
    ]
    for pat in forbidden:
        assert re.search(pat,s) is None,pat
    assert s.count("$$")%2==0
    tmp=re.sub(r"\$\$.*?\$\$","",s,flags=re.S)
    assert len(re.findall(r"(?<!\\)\$",tmp))%2==0
    return True

if __name__=="__main__":
    print("pole_transport",check_pole_transport())
    print("convolution_error",check_convolution())
    print("twisted_convolution_error",check_twisted_convolution())
    print("principal_euler_zero_line",check_principal_euler_zero_line())
    print("source_delimiters",check_source())
    print("PASS")