File size: 7,930 Bytes
1263695 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 | #!/usr/bin/env python3
"""Exact scalar reductions and a reference fully polynomial ADDITIVE scheme.
All model arithmetic is rational. The approximation routine uses the classical
randomized determinant method for exact weighted bipartite matching. It always
returns a valid order; its objective guarantee is probabilistic. The elementary
implementation is intended for small instances, not as an optimized solver.
"""
from fractions import Fraction as F
from math import prod, isqrt
import random
def ceil_fraction(x):
return -((-x.numerator)//x.denominator)
def build_scalar_reduction(values, rho=F(1, 2)):
values=list(values)
rho=F(rho)
if not values or any(not isinstance(a,int) or a<=0 for a in values):
raise ValueError('PARTITION values must be positive integers')
if not 0<rho<1:
raise ValueError('rho must be strictly between zero and one')
n=len(values); N=2*n
r,s=rho.numerator,rho.denominator
weights=[r**(N-p)*s**(p-1) for p in range(1,N+1)]
W=sum(weights); base=W+1
gaps=[weights[2*i+1]-weights[2*i] for i in range(n)]
H=prod(gaps)
data=[a*H//g for a,g in zip(values,gaps)]
D=2*max(weights)*sum(data)
Q=2*D+1
markers=[base**i for i in range(n)]
target=Q*sum(markers[i]*(weights[2*i]+weights[2*i+1]) for i in range(n))
raw=[]
for marker,c in zip(markers,data):
raw.extend([Q*marker+c,Q*marker-c])
bias=F(target,W)
shifted=[F(v)-bias for v in raw]
R=1+ceil_fraction(2*max(abs(v) for v in shifted)/(1-rho))
centers=[v/((1-rho)*R) for v in shifted]
gap=F(1,s**(N-1)*R)
return dict(values=values,rho=rho,n=n,N=N,weights=weights,W=W,base=base,
gaps=gaps,H=H,data=data,D=D,Q=Q,markers=markers,target=target,
raw=raw,bias=bias,R=R,centers=centers,gap=gap)
def endpoint(centers, order, rho=F(1,2), initial=F(0)):
x=F(initial); rho=F(rho)
for j in order:
x=rho*x+(1-rho)*F(centers[j])
return x
def raw_residual(model, order):
return sum(w*model['raw'][j] for w,j in zip(model['weights'],order))-model['target']
def determinant_mod(matrix, p):
a=[row[:] for row in matrix]
n=len(a); answer=1
for i in range(n):
pivot=next((j for j in range(i,n) if a[j][i]%p),None)
if pivot is None:return 0
if pivot!=i:
a[i],a[pivot]=a[pivot],a[i]
answer=-answer
v=a[i][i]%p
answer=answer*v%p
inv=pow(v,p-2,p)
for j in range(i+1,n):
factor=a[j][i]*inv%p
if factor:
for k in range(i+1,n):a[j][k]=(a[j][k]-factor*a[i][k])%p
a[j][i]=0
return answer%p
def interpolate_consecutive(values,p):
"""Recover coefficients from values at 0,1,...,D, with p>D."""
work=[v%p for v in values]
D=len(work)-1
if D>=p:raise ValueError('field is too small for interpolation')
differences=[]
while work:
differences.append(work[0])
work=[(work[i+1]-work[i])%p for i in range(len(work)-1)]
result=[0]*(D+1)
basis=[1]
for j,c in enumerate(differences):
for k,b in enumerate(basis):result[k]=(result[k]+c*b)%p
if j<D:
following=[0]*(len(basis)+1)
for k,b in enumerate(basis):
following[k]=(following[k]-j*b)%p
following[k+1]=(following[k+1]+b)%p
inverse=pow(j+1,p-2,p)
basis=[x*inverse%p for x in following]
return result
def is_prime(n):
if n<2:return False
if n%2==0:return n==2
return all(n%d for d in range(3,isqrt(n)+1,2))
def next_prime(n):
n=max(2,n)
while not is_prime(n):n+=1
return n
def degree_bound(costs):
if not costs:return 0
return sum(max((v for v in row if v is not None),default=0) for row in costs)
def coefficient_oracle(costs,p,rng,stats=None):
"""Return a subset of the attainable perfect-matching weights.
There are no false positives. Each genuine coefficient vanishes with
probability at most n/|S|, where S is a dyadic subset of the field.
Every label uses a fixed number of independent unbiased random bits.
"""
n=len(costs)
if n==0:return {0}
if any(all(v is None for v in row) for row in costs):return set()
D=degree_bound(costs)
if p<=D:raise ValueError('field is too small')
label_bits=p.bit_length()-1
labels=[[rng.getrandbits(label_bits) for _ in row] for row in costs]
values=[]
for x in range(D+1):
matrix=[[0 if v is None else labels[i][j]*pow(x,v,p)%p
for j,v in enumerate(row)] for i,row in enumerate(costs)]
values.append(determinant_mod(matrix,p))
coeff=interpolate_consecutive(values,p)
if stats is not None:
stats['oracle_calls']=stats.get('oracle_calls',0)+1
stats['determinants']=stats.get('determinants',0)+D+1
return {q for q,c in enumerate(coeff) if c}
def recover_order(costs,target,p,rng,stats=None):
n=len(costs); columns=list(range(n)); answer=[]
original_target=target
for i in range(n):
chosen=None
for j in columns:
value=costs[i][j]
if value is None or target<value:continue
remainder=target-value
rest=[c for c in columns if c!=j]
minor=[[costs[row][c] for c in rest] for row in range(i+1,n)]
support=coefficient_oracle(minor,p,rng,stats)
if remainder in support:
chosen=j;target=remainder;break
if chosen is None:return None
answer.append(chosen);columns.remove(chosen)
if target or sum(costs[i][j] for i,j in enumerate(answer))!=original_target:
return None
return answer
def approximate_scalar_order(centers,rho=F(1,2),epsilon=F(1,4),
failure_probability=F(1,4),initial=F(0),
target=F(0),rng=None):
"""Return a valid order with J <= OPT+epsilon with probability >=1-beta.
Runtime is polynomial in input bit length, 1/epsilon, and log(1/beta).
Default randomness is from SystemRandom. Pass an RNG only for reproducible
finite experiments; a fixed seed is not an adversarial probability bound.
"""
centers=[F(x) for x in centers]
n=len(centers);rho=F(rho);epsilon=F(epsilon)
beta=F(failure_probability);initial=F(initial);target=F(target)
if not n or not 0<rho<1 or not 0<epsilon<=1 or not 0<beta<1:
raise ValueError('invalid size or approximation parameters')
if any(abs(x)>1 for x in centers) or abs(initial)>1 or abs(target)>1:
raise ValueError('centers, initial state, and target must lie in [-1,1]')
rng=rng or random.SystemRandom()
delta=epsilon/(16*n)
weights=[(1-rho)*rho**(n-1-i) for i in range(n)]
rounded=[[int((w*t)//delta) for t in centers] for w in weights]
row_min=[min(row) for row in rounded]
costs=[[x-a for x in row] for row,a in zip(rounded,row_min)]
offset=sum(row_min)
constant=rho**n*initial-target
D=degree_bound(costs)
p=next_prime(16*n**3*(D+1)+1)
repeats=1
while F(1,4)**repeats>beta:repeats+=1
best=list(range(n));best_value=(endpoint(centers,best,rho,initial)-target)**2
stats=dict(degree=D,field_prime=p,repeats=repeats,oracle_calls=0,
determinants=0,fallback_rounds=0)
for _ in range(repeats):
support=coefficient_oracle(costs,p,rng,stats)
if support:
q=min(support,key=lambda z:(constant+delta*(z+offset))**2)
order=recover_order(costs,q,p,rng,stats)
else:order=None
if order is None:
stats['fallback_rounds']+=1;continue
assert sorted(order)==list(range(n))
value=(endpoint(centers,order,rho,initial)-target)**2
if value<best_value:best=order;best_value=value
return dict(order=best,objective=best_value,statistics=stats,
epsilon=epsilon,failure_probability=beta)
|